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   if(!arg1) {
33807     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33808     return -1;
33809   }
33810
33811   {
33812     try {
33813       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33829       };
33830     }
33831   }
33832
33833   jresult = result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33839   unsigned int jresult ;
33840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33841   bool result;
33842
33843   arg1 = (Dali::Actor *)jarg1;
33844   {
33845     try {
33846       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33862       };
33863     }
33864   }
33865
33866   jresult = result;
33867   return jresult;
33868 }
33869
33870
33871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33872   unsigned int jresult ;
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   bool result;
33875
33876   arg1 = (Dali::Actor *)jarg1;
33877   {
33878     try {
33879       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33880     } catch (std::out_of_range& e) {
33881       {
33882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (std::exception& e) {
33885       {
33886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (Dali::DaliException e) {
33889       {
33890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33891       };
33892     } catch (...) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33895       };
33896     }
33897   }
33898
33899   jresult = result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33905   unsigned int jresult ;
33906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33907   bool result;
33908
33909   arg1 = (Dali::Actor *)jarg1;
33910   {
33911     try {
33912       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33913     } catch (std::out_of_range& e) {
33914       {
33915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (std::exception& e) {
33918       {
33919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (Dali::DaliException e) {
33922       {
33923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33924       };
33925     } catch (...) {
33926       {
33927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33928       };
33929     }
33930   }
33931
33932   jresult = result;
33933   return jresult;
33934 }
33935
33936
33937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33938   void * jresult ;
33939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33940   Dali::Layer result;
33941
33942   arg1 = (Dali::Actor *)jarg1;
33943   {
33944     try {
33945       result = (arg1)->GetLayer();
33946     } catch (std::out_of_range& e) {
33947       {
33948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33949       };
33950     } catch (std::exception& e) {
33951       {
33952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33953       };
33954     } catch (Dali::DaliException e) {
33955       {
33956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33957       };
33958     } catch (...) {
33959       {
33960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33961       };
33962     }
33963   }
33964
33965   jresult = new Dali::Layer((const Dali::Layer &)result);
33966   return jresult;
33967 }
33968
33969
33970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33972   Dali::Actor arg2 ;
33973   Dali::Actor *argp2 ;
33974
33975   arg1 = (Dali::Actor *)jarg1;
33976   argp2 = (Dali::Actor *)jarg2;
33977   if (!argp2) {
33978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33979     return ;
33980   }
33981   arg2 = *argp2;
33982   {
33983     try {
33984       (arg1)->Add(arg2);
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34000       };
34001     }
34002   }
34003
34004 }
34005
34006
34007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34009   Dali::Actor arg2 ;
34010   Dali::Actor *argp2 ;
34011
34012   arg1 = (Dali::Actor *)jarg1;
34013   argp2 = (Dali::Actor *)jarg2;
34014   if (!argp2) {
34015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34016     return ;
34017   }
34018   arg2 = *argp2;
34019   {
34020     try {
34021       (arg1)->Remove(arg2);
34022     } catch (std::out_of_range& e) {
34023       {
34024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34025       };
34026     } catch (std::exception& e) {
34027       {
34028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34029       };
34030     } catch (Dali::DaliException e) {
34031       {
34032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34033       };
34034     } catch (...) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34037       };
34038     }
34039   }
34040
34041 }
34042
34043
34044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34046
34047   arg1 = (Dali::Actor *)jarg1;
34048   {
34049     try {
34050       (arg1)->Unparent();
34051     } catch (std::out_of_range& e) {
34052       {
34053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34054       };
34055     } catch (std::exception& e) {
34056       {
34057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34058       };
34059     } catch (Dali::DaliException e) {
34060       {
34061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34062       };
34063     } catch (...) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34066       };
34067     }
34068   }
34069
34070 }
34071
34072
34073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34074   unsigned int jresult ;
34075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34076   unsigned int result;
34077
34078   arg1 = (Dali::Actor *)jarg1;
34079   {
34080     try {
34081       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34082     } catch (std::out_of_range& e) {
34083       {
34084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34085       };
34086     } catch (std::exception& e) {
34087       {
34088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34089       };
34090     } catch (Dali::DaliException e) {
34091       {
34092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34093       };
34094     } catch (...) {
34095       {
34096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34097       };
34098     }
34099   }
34100
34101   jresult = result;
34102   return jresult;
34103 }
34104
34105
34106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34107   void * jresult ;
34108   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34109   unsigned int arg2 ;
34110   Dali::Actor result;
34111
34112   arg1 = (Dali::Actor *)jarg1;
34113   arg2 = (unsigned int)jarg2;
34114   {
34115     try {
34116       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34117     } catch (std::out_of_range& e) {
34118       {
34119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34120       };
34121     } catch (std::exception& e) {
34122       {
34123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34124       };
34125     } catch (Dali::DaliException e) {
34126       {
34127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34128       };
34129     } catch (...) {
34130       {
34131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34132       };
34133     }
34134   }
34135
34136   jresult = new Dali::Actor((const Dali::Actor &)result);
34137   return jresult;
34138 }
34139
34140
34141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34142   void * jresult ;
34143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34144   std::string *arg2 = 0 ;
34145   Dali::Actor result;
34146
34147   arg1 = (Dali::Actor *)jarg1;
34148   if (!jarg2) {
34149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34150     return 0;
34151   }
34152   std::string arg2_str(jarg2);
34153   arg2 = &arg2_str;
34154   {
34155     try {
34156       result = (arg1)->FindChildByName((std::string const &)*arg2);
34157     } catch (std::out_of_range& e) {
34158       {
34159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34160       };
34161     } catch (std::exception& e) {
34162       {
34163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34164       };
34165     } catch (Dali::DaliException e) {
34166       {
34167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34168       };
34169     } catch (...) {
34170       {
34171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34172       };
34173     }
34174   }
34175
34176   jresult = new Dali::Actor((const Dali::Actor &)result);
34177
34178   //argout typemap for const std::string&
34179
34180   return jresult;
34181 }
34182
34183
34184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34185   void * jresult ;
34186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34187   unsigned int arg2 ;
34188   Dali::Actor result;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (unsigned int)jarg2;
34192   {
34193     try {
34194       result = (arg1)->FindChildById(arg2);
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34202       };
34203     } catch (Dali::DaliException e) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34206       };
34207     } catch (...) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34210       };
34211     }
34212   }
34213
34214   jresult = new Dali::Actor((const Dali::Actor &)result);
34215   return jresult;
34216 }
34217
34218
34219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34220   void * jresult ;
34221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34222   Dali::Actor result;
34223
34224   arg1 = (Dali::Actor *)jarg1;
34225   {
34226     try {
34227       result = ((Dali::Actor const *)arg1)->GetParent();
34228     } catch (std::out_of_range& e) {
34229       {
34230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34231       };
34232     } catch (std::exception& e) {
34233       {
34234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (Dali::DaliException e) {
34237       {
34238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34239       };
34240     } catch (...) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34243       };
34244     }
34245   }
34246
34247   jresult = new Dali::Actor((const Dali::Actor &)result);
34248   return jresult;
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34254   Dali::Vector3 *arg2 = 0 ;
34255
34256   arg1 = (Dali::Actor *)jarg1;
34257   arg2 = (Dali::Vector3 *)jarg2;
34258   if (!arg2) {
34259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34260     return ;
34261   }
34262   {
34263     try {
34264       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34280       };
34281     }
34282   }
34283
34284 }
34285
34286
34287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34288   void * jresult ;
34289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34290   Dali::Vector3 result;
34291
34292   arg1 = (Dali::Actor *)jarg1;
34293   {
34294     try {
34295       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (Dali::DaliException e) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34311       };
34312     }
34313   }
34314
34315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34322   Dali::Vector3 *arg2 = 0 ;
34323
34324   arg1 = (Dali::Actor *)jarg1;
34325   arg2 = (Dali::Vector3 *)jarg2;
34326   if (!arg2) {
34327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34328     return ;
34329   }
34330   {
34331     try {
34332       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34333     } catch (std::out_of_range& e) {
34334       {
34335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34336       };
34337     } catch (std::exception& e) {
34338       {
34339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (Dali::DaliException e) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34344       };
34345     } catch (...) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34348       };
34349     }
34350   }
34351
34352 }
34353
34354
34355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34356   void * jresult ;
34357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34358   Dali::Vector3 result;
34359
34360   arg1 = (Dali::Actor *)jarg1;
34361   {
34362     try {
34363       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34364     } catch (std::out_of_range& e) {
34365       {
34366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34367       };
34368     } catch (std::exception& e) {
34369       {
34370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34371       };
34372     } catch (Dali::DaliException e) {
34373       {
34374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34375       };
34376     } catch (...) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34379       };
34380     }
34381   }
34382
34383   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34384   return jresult;
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   float arg2 ;
34391   float arg3 ;
34392
34393   arg1 = (Dali::Actor *)jarg1;
34394   arg2 = (float)jarg2;
34395   arg3 = (float)jarg3;
34396   {
34397     try {
34398       (arg1)->SetSize(arg2,arg3);
34399     } catch (std::out_of_range& e) {
34400       {
34401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34402       };
34403     } catch (std::exception& e) {
34404       {
34405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34406       };
34407     } catch (Dali::DaliException e) {
34408       {
34409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34410       };
34411     } catch (...) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34414       };
34415     }
34416   }
34417
34418 }
34419
34420
34421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34423   float arg2 ;
34424   float arg3 ;
34425   float arg4 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (float)jarg2;
34429   arg3 = (float)jarg3;
34430   arg4 = (float)jarg4;
34431   {
34432     try {
34433       (arg1)->SetSize(arg2,arg3,arg4);
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (Dali::DaliException e) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34449       };
34450     }
34451   }
34452
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34458   Dali::Vector2 *arg2 = 0 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (Dali::Vector2 *)jarg2;
34462   if (!arg2) {
34463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34464     return ;
34465   }
34466   {
34467     try {
34468       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34469     } catch (std::out_of_range& e) {
34470       {
34471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34472       };
34473     } catch (std::exception& e) {
34474       {
34475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34476       };
34477     } catch (Dali::DaliException e) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34480       };
34481     } catch (...) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34484       };
34485     }
34486   }
34487
34488 }
34489
34490
34491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34493   Dali::Vector3 *arg2 = 0 ;
34494
34495   arg1 = (Dali::Actor *)jarg1;
34496   arg2 = (Dali::Vector3 *)jarg2;
34497   if (!arg2) {
34498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34499     return ;
34500   }
34501   {
34502     try {
34503       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34519       };
34520     }
34521   }
34522
34523 }
34524
34525
34526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34527   void * jresult ;
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   Dali::Vector3 result;
34530
34531   arg1 = (Dali::Actor *)jarg1;
34532   {
34533     try {
34534       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34535     } catch (std::out_of_range& e) {
34536       {
34537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34538       };
34539     } catch (std::exception& e) {
34540       {
34541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (Dali::DaliException e) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34546       };
34547     } catch (...) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34550       };
34551     }
34552   }
34553
34554   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34555   return jresult;
34556 }
34557
34558
34559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34560   void * jresult ;
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   Dali::Vector3 result;
34563
34564   arg1 = (Dali::Actor *)jarg1;
34565   {
34566     try {
34567       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34568     } catch (std::out_of_range& e) {
34569       {
34570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34571       };
34572     } catch (std::exception& e) {
34573       {
34574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34575       };
34576     } catch (Dali::DaliException e) {
34577       {
34578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34579       };
34580     } catch (...) {
34581       {
34582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34583       };
34584     }
34585   }
34586
34587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34588   return jresult;
34589 }
34590
34591
34592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34593   void * jresult ;
34594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34595   Dali::Vector3 result;
34596
34597   arg1 = (Dali::Actor *)jarg1;
34598   {
34599     try {
34600       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34601     } catch (std::out_of_range& e) {
34602       {
34603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34604       };
34605     } catch (std::exception& e) {
34606       {
34607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34608       };
34609     } catch (Dali::DaliException e) {
34610       {
34611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34612       };
34613     } catch (...) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34616       };
34617     }
34618   }
34619
34620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34621   return jresult;
34622 }
34623
34624
34625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34627   float arg2 ;
34628   float arg3 ;
34629
34630   arg1 = (Dali::Actor *)jarg1;
34631   arg2 = (float)jarg2;
34632   arg3 = (float)jarg3;
34633   {
34634     try {
34635       (arg1)->SetPosition(arg2,arg3);
34636     } catch (std::out_of_range& e) {
34637       {
34638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34639       };
34640     } catch (std::exception& e) {
34641       {
34642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (Dali::DaliException e) {
34645       {
34646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34647       };
34648     } catch (...) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34651       };
34652     }
34653   }
34654
34655 }
34656
34657
34658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34660   float arg2 ;
34661   float arg3 ;
34662   float arg4 ;
34663
34664   arg1 = (Dali::Actor *)jarg1;
34665   arg2 = (float)jarg2;
34666   arg3 = (float)jarg3;
34667   arg4 = (float)jarg4;
34668   {
34669     try {
34670       (arg1)->SetPosition(arg2,arg3,arg4);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (Dali::DaliException e) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34686       };
34687     }
34688   }
34689
34690 }
34691
34692
34693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34695   Dali::Vector3 *arg2 = 0 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (Dali::Vector3 *)jarg2;
34699   if (!arg2) {
34700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34701     return ;
34702   }
34703   {
34704     try {
34705       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (Dali::DaliException e) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34717       };
34718     } catch (...) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34721       };
34722     }
34723   }
34724
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34730   float arg2 ;
34731
34732   arg1 = (Dali::Actor *)jarg1;
34733   arg2 = (float)jarg2;
34734   {
34735     try {
34736       (arg1)->SetX(arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   float arg2 ;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   arg2 = (float)jarg2;
34765   {
34766     try {
34767       (arg1)->SetY(arg2);
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34783       };
34784     }
34785   }
34786
34787 }
34788
34789
34790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34791   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34792   float arg2 ;
34793
34794   arg1 = (Dali::Actor *)jarg1;
34795   arg2 = (float)jarg2;
34796   {
34797     try {
34798       (arg1)->SetZ(arg2);
34799     } catch (std::out_of_range& e) {
34800       {
34801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34802       };
34803     } catch (std::exception& e) {
34804       {
34805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34806       };
34807     } catch (Dali::DaliException e) {
34808       {
34809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34814       };
34815     }
34816   }
34817
34818 }
34819
34820
34821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34823   Dali::Vector3 *arg2 = 0 ;
34824
34825   arg1 = (Dali::Actor *)jarg1;
34826   arg2 = (Dali::Vector3 *)jarg2;
34827   if (!arg2) {
34828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34829     return ;
34830   }
34831   {
34832     try {
34833       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (Dali::DaliException e) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34857   void * jresult ;
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   Dali::Vector3 result;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   {
34863     try {
34864       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34865     } catch (std::out_of_range& e) {
34866       {
34867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (std::exception& e) {
34870       {
34871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (Dali::DaliException e) {
34874       {
34875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883
34884   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34890   void * jresult ;
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Vector3 result;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   {
34896     try {
34897       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34898     } catch (std::out_of_range& e) {
34899       {
34900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34901       };
34902     } catch (std::exception& e) {
34903       {
34904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34905       };
34906     } catch (Dali::DaliException e) {
34907       {
34908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34909       };
34910     } catch (...) {
34911       {
34912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34913       };
34914     }
34915   }
34916
34917   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34918   return jresult;
34919 }
34920
34921
34922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34924   bool arg2 ;
34925
34926   arg1 = (Dali::Actor *)jarg1;
34927   arg2 = jarg2 ? true : false;
34928   {
34929     try {
34930       (arg1)->SetInheritPosition(arg2);
34931     } catch (std::out_of_range& e) {
34932       {
34933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34934       };
34935     } catch (std::exception& e) {
34936       {
34937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34938       };
34939     } catch (Dali::DaliException e) {
34940       {
34941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34946       };
34947     }
34948   }
34949
34950 }
34951
34952
34953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34954   unsigned int jresult ;
34955   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34956   bool result;
34957
34958   arg1 = (Dali::Actor *)jarg1;
34959   {
34960     try {
34961       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34962     } catch (std::out_of_range& e) {
34963       {
34964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (std::exception& e) {
34967       {
34968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34969       };
34970     } catch (Dali::DaliException e) {
34971       {
34972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34973       };
34974     } catch (...) {
34975       {
34976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34977       };
34978     }
34979   }
34980
34981   jresult = result;
34982   return jresult;
34983 }
34984
34985
34986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34988   Dali::Degree *arg2 = 0 ;
34989   Dali::Vector3 *arg3 = 0 ;
34990
34991   arg1 = (Dali::Actor *)jarg1;
34992   arg2 = (Dali::Degree *)jarg2;
34993   if (!arg2) {
34994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34995     return ;
34996   }
34997   arg3 = (Dali::Vector3 *)jarg3;
34998   if (!arg3) {
34999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35000     return ;
35001   }
35002   {
35003     try {
35004       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35005     } catch (std::out_of_range& e) {
35006       {
35007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35008       };
35009     } catch (std::exception& e) {
35010       {
35011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35012       };
35013     } catch (Dali::DaliException e) {
35014       {
35015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35016       };
35017     } catch (...) {
35018       {
35019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35020       };
35021     }
35022   }
35023
35024 }
35025
35026
35027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35029   Dali::Radian *arg2 = 0 ;
35030   Dali::Vector3 *arg3 = 0 ;
35031
35032   arg1 = (Dali::Actor *)jarg1;
35033   arg2 = (Dali::Radian *)jarg2;
35034   if (!arg2) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35036     return ;
35037   }
35038   arg3 = (Dali::Vector3 *)jarg3;
35039   if (!arg3) {
35040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35041     return ;
35042   }
35043   {
35044     try {
35045       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35046     } catch (std::out_of_range& e) {
35047       {
35048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35049       };
35050     } catch (std::exception& e) {
35051       {
35052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35053       };
35054     } catch (Dali::DaliException e) {
35055       {
35056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35057       };
35058     } catch (...) {
35059       {
35060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35061       };
35062     }
35063   }
35064
35065 }
35066
35067
35068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35070   Dali::Quaternion *arg2 = 0 ;
35071
35072   arg1 = (Dali::Actor *)jarg1;
35073   arg2 = (Dali::Quaternion *)jarg2;
35074   if (!arg2) {
35075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35076     return ;
35077   }
35078   {
35079     try {
35080       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35081     } catch (std::out_of_range& e) {
35082       {
35083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35084       };
35085     } catch (std::exception& e) {
35086       {
35087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35088       };
35089     } catch (Dali::DaliException e) {
35090       {
35091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35092       };
35093     } catch (...) {
35094       {
35095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35096       };
35097     }
35098   }
35099
35100 }
35101
35102
35103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35105   Dali::Degree *arg2 = 0 ;
35106   Dali::Vector3 *arg3 = 0 ;
35107
35108   arg1 = (Dali::Actor *)jarg1;
35109   arg2 = (Dali::Degree *)jarg2;
35110   if (!arg2) {
35111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35112     return ;
35113   }
35114   arg3 = (Dali::Vector3 *)jarg3;
35115   if (!arg3) {
35116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35117     return ;
35118   }
35119   {
35120     try {
35121       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35122     } catch (std::out_of_range& e) {
35123       {
35124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35125       };
35126     } catch (std::exception& e) {
35127       {
35128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35129       };
35130     } catch (Dali::DaliException e) {
35131       {
35132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35133       };
35134     } catch (...) {
35135       {
35136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35137       };
35138     }
35139   }
35140
35141 }
35142
35143
35144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35146   Dali::Radian *arg2 = 0 ;
35147   Dali::Vector3 *arg3 = 0 ;
35148
35149   arg1 = (Dali::Actor *)jarg1;
35150   arg2 = (Dali::Radian *)jarg2;
35151   if (!arg2) {
35152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35153     return ;
35154   }
35155   arg3 = (Dali::Vector3 *)jarg3;
35156   if (!arg3) {
35157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35158     return ;
35159   }
35160   {
35161     try {
35162       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35163     } catch (std::out_of_range& e) {
35164       {
35165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35166       };
35167     } catch (std::exception& e) {
35168       {
35169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35170       };
35171     } catch (Dali::DaliException e) {
35172       {
35173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35174       };
35175     } catch (...) {
35176       {
35177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35178       };
35179     }
35180   }
35181
35182 }
35183
35184
35185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35187   Dali::Quaternion *arg2 = 0 ;
35188
35189   arg1 = (Dali::Actor *)jarg1;
35190   arg2 = (Dali::Quaternion *)jarg2;
35191   if (!arg2) {
35192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35193     return ;
35194   }
35195   {
35196     try {
35197       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35198     } catch (std::out_of_range& e) {
35199       {
35200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35201       };
35202     } catch (std::exception& e) {
35203       {
35204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35205       };
35206     } catch (Dali::DaliException e) {
35207       {
35208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35209       };
35210     } catch (...) {
35211       {
35212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35213       };
35214     }
35215   }
35216
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35221   void * jresult ;
35222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35223   Dali::Quaternion result;
35224
35225   arg1 = (Dali::Actor *)jarg1;
35226   {
35227     try {
35228       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (Dali::DaliException e) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35240       };
35241     } catch (...) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35244       };
35245     }
35246   }
35247
35248   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35249   return jresult;
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   bool arg2 ;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   arg2 = jarg2 ? true : false;
35259   {
35260     try {
35261       (arg1)->SetInheritOrientation(arg2);
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35285   unsigned int jresult ;
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   bool result;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   {
35291     try {
35292       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35293     } catch (std::out_of_range& e) {
35294       {
35295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (std::exception& e) {
35298       {
35299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35300       };
35301     } catch (Dali::DaliException e) {
35302       {
35303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35304       };
35305     } catch (...) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35308       };
35309     }
35310   }
35311
35312   jresult = result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35318   void * jresult ;
35319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35320   Dali::Quaternion result;
35321
35322   arg1 = (Dali::Actor *)jarg1;
35323   {
35324     try {
35325       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35326     } catch (std::out_of_range& e) {
35327       {
35328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (std::exception& e) {
35331       {
35332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35333       };
35334     } catch (Dali::DaliException e) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35337       };
35338     } catch (...) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35341       };
35342     }
35343   }
35344
35345   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35346   return jresult;
35347 }
35348
35349
35350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35352   float arg2 ;
35353
35354   arg1 = (Dali::Actor *)jarg1;
35355   arg2 = (float)jarg2;
35356   {
35357     try {
35358       (arg1)->SetScale(arg2);
35359     } catch (std::out_of_range& e) {
35360       {
35361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35362       };
35363     } catch (std::exception& e) {
35364       {
35365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35366       };
35367     } catch (Dali::DaliException e) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35370       };
35371     } catch (...) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35374       };
35375     }
35376   }
35377
35378 }
35379
35380
35381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35383   float arg2 ;
35384   float arg3 ;
35385   float arg4 ;
35386
35387   arg1 = (Dali::Actor *)jarg1;
35388   arg2 = (float)jarg2;
35389   arg3 = (float)jarg3;
35390   arg4 = (float)jarg4;
35391   {
35392     try {
35393       (arg1)->SetScale(arg2,arg3,arg4);
35394     } catch (std::out_of_range& e) {
35395       {
35396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35397       };
35398     } catch (std::exception& e) {
35399       {
35400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35401       };
35402     } catch (Dali::DaliException e) {
35403       {
35404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35405       };
35406     } catch (...) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35409       };
35410     }
35411   }
35412
35413 }
35414
35415
35416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35417   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35418   Dali::Vector3 *arg2 = 0 ;
35419
35420   arg1 = (Dali::Actor *)jarg1;
35421   arg2 = (Dali::Vector3 *)jarg2;
35422   if (!arg2) {
35423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35424     return ;
35425   }
35426   {
35427     try {
35428       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35429     } catch (std::out_of_range& e) {
35430       {
35431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35432       };
35433     } catch (std::exception& e) {
35434       {
35435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (Dali::DaliException e) {
35438       {
35439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35440       };
35441     } catch (...) {
35442       {
35443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35444       };
35445     }
35446   }
35447
35448 }
35449
35450
35451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35453   Dali::Vector3 *arg2 = 0 ;
35454
35455   arg1 = (Dali::Actor *)jarg1;
35456   arg2 = (Dali::Vector3 *)jarg2;
35457   if (!arg2) {
35458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35459     return ;
35460   }
35461   {
35462     try {
35463       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35471       };
35472     } catch (Dali::DaliException e) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35475       };
35476     } catch (...) {
35477       {
35478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35479       };
35480     }
35481   }
35482
35483 }
35484
35485
35486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35487   void * jresult ;
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   Dali::Vector3 result;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   {
35493     try {
35494       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35495     } catch (std::out_of_range& e) {
35496       {
35497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35498       };
35499     } catch (std::exception& e) {
35500       {
35501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (Dali::DaliException e) {
35504       {
35505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35506       };
35507     } catch (...) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35510       };
35511     }
35512   }
35513
35514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35515   return jresult;
35516 }
35517
35518
35519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35520   void * jresult ;
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Vector3 result;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   {
35526     try {
35527       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (Dali::DaliException e) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546
35547   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35548   return jresult;
35549 }
35550
35551
35552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35554   bool arg2 ;
35555
35556   arg1 = (Dali::Actor *)jarg1;
35557   arg2 = jarg2 ? true : false;
35558   {
35559     try {
35560       (arg1)->SetInheritScale(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (Dali::DaliException e) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35572       };
35573     } catch (...) {
35574       {
35575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35576       };
35577     }
35578   }
35579
35580 }
35581
35582
35583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35584   unsigned int jresult ;
35585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35586   bool result;
35587
35588   arg1 = (Dali::Actor *)jarg1;
35589   {
35590     try {
35591       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35592     } catch (std::out_of_range& e) {
35593       {
35594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (std::exception& e) {
35597       {
35598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (Dali::DaliException e) {
35601       {
35602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35603       };
35604     } catch (...) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35607       };
35608     }
35609   }
35610
35611   jresult = result;
35612   return jresult;
35613 }
35614
35615
35616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35617   void * jresult ;
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   Dali::Matrix result;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   {
35623     try {
35624       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35632       };
35633     } catch (Dali::DaliException e) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35640       };
35641     }
35642   }
35643
35644   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35645   return jresult;
35646 }
35647
35648
35649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   bool arg2 ;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   arg2 = jarg2 ? true : false;
35655   {
35656     try {
35657       (arg1)->SetVisible(arg2);
35658     } catch (std::out_of_range& e) {
35659       {
35660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35661       };
35662     } catch (std::exception& e) {
35663       {
35664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35665       };
35666     } catch (Dali::DaliException e) {
35667       {
35668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35669       };
35670     } catch (...) {
35671       {
35672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35673       };
35674     }
35675   }
35676
35677 }
35678
35679
35680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35681   unsigned int jresult ;
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   bool result;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   {
35687     try {
35688       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35689     } catch (std::out_of_range& e) {
35690       {
35691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (std::exception& e) {
35694       {
35695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35696       };
35697     } catch (Dali::DaliException e) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35700       };
35701     } catch (...) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35704       };
35705     }
35706   }
35707
35708   jresult = result;
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35715   float arg2 ;
35716
35717   arg1 = (Dali::Actor *)jarg1;
35718   arg2 = (float)jarg2;
35719   {
35720     try {
35721       (arg1)->SetOpacity(arg2);
35722     } catch (std::out_of_range& e) {
35723       {
35724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35725       };
35726     } catch (std::exception& e) {
35727       {
35728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35729       };
35730     } catch (Dali::DaliException e) {
35731       {
35732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35733       };
35734     } catch (...) {
35735       {
35736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35737       };
35738     }
35739   }
35740
35741 }
35742
35743
35744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35745   float jresult ;
35746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35747   float result;
35748
35749   arg1 = (Dali::Actor *)jarg1;
35750   {
35751     try {
35752       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35753     } catch (std::out_of_range& e) {
35754       {
35755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35756       };
35757     } catch (std::exception& e) {
35758       {
35759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35760       };
35761     } catch (Dali::DaliException e) {
35762       {
35763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35764       };
35765     } catch (...) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35768       };
35769     }
35770   }
35771
35772   jresult = result;
35773   return jresult;
35774 }
35775
35776
35777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35779   Dali::Vector4 *arg2 = 0 ;
35780
35781   arg1 = (Dali::Actor *)jarg1;
35782   arg2 = (Dali::Vector4 *)jarg2;
35783   if (!arg2) {
35784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35785     return ;
35786   }
35787   {
35788     try {
35789       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35790     } catch (std::out_of_range& e) {
35791       {
35792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35793       };
35794     } catch (std::exception& e) {
35795       {
35796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35797       };
35798     } catch (Dali::DaliException e) {
35799       {
35800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35801       };
35802     } catch (...) {
35803       {
35804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35805       };
35806     }
35807   }
35808
35809 }
35810
35811
35812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35813   void * jresult ;
35814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35815   Dali::Vector4 result;
35816
35817   arg1 = (Dali::Actor *)jarg1;
35818   {
35819     try {
35820       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35821     } catch (std::out_of_range& e) {
35822       {
35823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (std::exception& e) {
35826       {
35827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (Dali::DaliException e) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35832       };
35833     } catch (...) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35836       };
35837     }
35838   }
35839
35840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35841   return jresult;
35842 }
35843
35844
35845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35847   Dali::ColorMode arg2 ;
35848
35849   arg1 = (Dali::Actor *)jarg1;
35850   arg2 = (Dali::ColorMode)jarg2;
35851   {
35852     try {
35853       (arg1)->SetColorMode(arg2);
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35861       };
35862     } catch (Dali::DaliException e) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35869       };
35870     }
35871   }
35872
35873 }
35874
35875
35876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35877   int jresult ;
35878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35879   Dali::ColorMode result;
35880
35881   arg1 = (Dali::Actor *)jarg1;
35882   {
35883     try {
35884       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (Dali::DaliException e) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35896       };
35897     } catch (...) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35900       };
35901     }
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35910   void * jresult ;
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   Dali::Vector4 result;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   {
35916     try {
35917       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35918     } catch (std::out_of_range& e) {
35919       {
35920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35921       };
35922     } catch (std::exception& e) {
35923       {
35924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35925       };
35926     } catch (Dali::DaliException e) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35929       };
35930     } catch (...) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35933       };
35934     }
35935   }
35936
35937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35938   return jresult;
35939 }
35940
35941
35942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   Dali::DrawMode::Type arg2 ;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   arg2 = (Dali::DrawMode::Type)jarg2;
35948   {
35949     try {
35950       (arg1)->SetDrawMode(arg2);
35951     } catch (std::out_of_range& e) {
35952       {
35953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35954       };
35955     } catch (std::exception& e) {
35956       {
35957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35958       };
35959     } catch (Dali::DaliException e) {
35960       {
35961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35966       };
35967     }
35968   }
35969
35970 }
35971
35972
35973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35974   int jresult ;
35975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35976   Dali::DrawMode::Type result;
35977
35978   arg1 = (Dali::Actor *)jarg1;
35979   {
35980     try {
35981       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35982     } catch (std::out_of_range& e) {
35983       {
35984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (std::exception& e) {
35987       {
35988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35989       };
35990     } catch (Dali::DaliException e) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35993       };
35994     } catch (...) {
35995       {
35996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35997       };
35998     }
35999   }
36000
36001   jresult = (int)result;
36002   return jresult;
36003 }
36004
36005
36006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36008   bool arg2 ;
36009
36010   arg1 = (Dali::Actor *)jarg1;
36011   arg2 = jarg2 ? true : false;
36012   {
36013     try {
36014       (arg1)->SetSensitive(arg2);
36015     } catch (std::out_of_range& e) {
36016       {
36017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (std::exception& e) {
36020       {
36021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36022       };
36023     } catch (Dali::DaliException e) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36026       };
36027     } catch (...) {
36028       {
36029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36030       };
36031     }
36032   }
36033
36034 }
36035
36036
36037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36038   unsigned int jresult ;
36039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36040   bool result;
36041
36042   arg1 = (Dali::Actor *)jarg1;
36043   {
36044     try {
36045       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36046     } catch (std::out_of_range& e) {
36047       {
36048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (std::exception& e) {
36051       {
36052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36053       };
36054     } catch (Dali::DaliException e) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36057       };
36058     } catch (...) {
36059       {
36060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36061       };
36062     }
36063   }
36064
36065   jresult = result;
36066   return jresult;
36067 }
36068
36069
36070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36071   unsigned int jresult ;
36072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36073   float *arg2 = 0 ;
36074   float *arg3 = 0 ;
36075   float arg4 ;
36076   float arg5 ;
36077   bool result;
36078
36079   arg1 = (Dali::Actor *)jarg1;
36080   arg2 = (float *)jarg2;
36081   arg3 = (float *)jarg3;
36082   arg4 = (float)jarg4;
36083   arg5 = (float)jarg5;
36084   {
36085     try {
36086       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36102       };
36103     }
36104   }
36105
36106   jresult = result;
36107   return jresult;
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool arg2 ;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   arg2 = jarg2 ? true : false;
36117   {
36118     try {
36119       (arg1)->SetLeaveRequired(arg2);
36120     } catch (std::out_of_range& e) {
36121       {
36122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36123       };
36124     } catch (std::exception& e) {
36125       {
36126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36127       };
36128     } catch (Dali::DaliException e) {
36129       {
36130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36131       };
36132     } catch (...) {
36133       {
36134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36135       };
36136     }
36137   }
36138
36139 }
36140
36141
36142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36143   unsigned int jresult ;
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   bool result;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   {
36149     try {
36150       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (Dali::DaliException e) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36162       };
36163     } catch (...) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36166       };
36167     }
36168   }
36169
36170   jresult = result;
36171   return jresult;
36172 }
36173
36174
36175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   bool arg2 ;
36178
36179   arg1 = (Dali::Actor *)jarg1;
36180   arg2 = jarg2 ? true : false;
36181   {
36182     try {
36183       (arg1)->SetKeyboardFocusable(arg2);
36184     } catch (std::out_of_range& e) {
36185       {
36186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36187       };
36188     } catch (std::exception& e) {
36189       {
36190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36191       };
36192     } catch (Dali::DaliException e) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36195       };
36196     } catch (...) {
36197       {
36198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36199       };
36200     }
36201   }
36202
36203 }
36204
36205
36206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36207   unsigned int jresult ;
36208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36209   bool result;
36210
36211   arg1 = (Dali::Actor *)jarg1;
36212   {
36213     try {
36214       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36241   Dali::ResizePolicy::Type arg2 ;
36242   Dali::Dimension::Type arg3 ;
36243
36244   arg1 = (Dali::Actor *)jarg1;
36245   arg2 = (Dali::ResizePolicy::Type)jarg2;
36246   arg3 = (Dali::Dimension::Type)jarg3;
36247   {
36248     try {
36249       (arg1)->SetResizePolicy(arg2,arg3);
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36265       };
36266     }
36267   }
36268
36269 }
36270
36271
36272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36273   int jresult ;
36274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36275   Dali::Dimension::Type arg2 ;
36276   Dali::ResizePolicy::Type result;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Dimension::Type)jarg2;
36280   {
36281     try {
36282       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (Dali::DaliException e) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36294       };
36295     } catch (...) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36298       };
36299     }
36300   }
36301
36302   jresult = (int)result;
36303   return jresult;
36304 }
36305
36306
36307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36309   Dali::SizeScalePolicy::Type arg2 ;
36310
36311   arg1 = (Dali::Actor *)jarg1;
36312   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36313   {
36314     try {
36315       (arg1)->SetSizeScalePolicy(arg2);
36316     } catch (std::out_of_range& e) {
36317       {
36318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36319       };
36320     } catch (std::exception& e) {
36321       {
36322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36323       };
36324     } catch (Dali::DaliException e) {
36325       {
36326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36327       };
36328     } catch (...) {
36329       {
36330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36331       };
36332     }
36333   }
36334
36335 }
36336
36337
36338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36339   int jresult ;
36340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36341   Dali::SizeScalePolicy::Type result;
36342
36343   arg1 = (Dali::Actor *)jarg1;
36344   {
36345     try {
36346       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36347     } catch (std::out_of_range& e) {
36348       {
36349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36350       };
36351     } catch (std::exception& e) {
36352       {
36353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36354       };
36355     } catch (Dali::DaliException e) {
36356       {
36357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36358       };
36359     } catch (...) {
36360       {
36361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36362       };
36363     }
36364   }
36365
36366   jresult = (int)result;
36367   return jresult;
36368 }
36369
36370
36371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36373   Dali::Vector3 *arg2 = 0 ;
36374
36375   arg1 = (Dali::Actor *)jarg1;
36376   arg2 = (Dali::Vector3 *)jarg2;
36377   if (!arg2) {
36378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36379     return ;
36380   }
36381   {
36382     try {
36383       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36391       };
36392     } catch (Dali::DaliException e) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36395       };
36396     } catch (...) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36399       };
36400     }
36401   }
36402
36403 }
36404
36405
36406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36407   void * jresult ;
36408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36409   Dali::Vector3 result;
36410
36411   arg1 = (Dali::Actor *)jarg1;
36412   {
36413     try {
36414       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36415     } catch (std::out_of_range& e) {
36416       {
36417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36418       };
36419     } catch (std::exception& e) {
36420       {
36421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (Dali::DaliException e) {
36424       {
36425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36426       };
36427     } catch (...) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36430       };
36431     }
36432   }
36433
36434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36435   return jresult;
36436 }
36437
36438
36439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36440   float jresult ;
36441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36442   float arg2 ;
36443   float result;
36444
36445   arg1 = (Dali::Actor *)jarg1;
36446   arg2 = (float)jarg2;
36447   {
36448     try {
36449       result = (float)(arg1)->GetHeightForWidth(arg2);
36450     } catch (std::out_of_range& e) {
36451       {
36452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36453       };
36454     } catch (std::exception& e) {
36455       {
36456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36457       };
36458     } catch (Dali::DaliException e) {
36459       {
36460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36461       };
36462     } catch (...) {
36463       {
36464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36465       };
36466     }
36467   }
36468
36469   jresult = result;
36470   return jresult;
36471 }
36472
36473
36474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36475   float jresult ;
36476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36477   float arg2 ;
36478   float result;
36479
36480   arg1 = (Dali::Actor *)jarg1;
36481   arg2 = (float)jarg2;
36482   {
36483     try {
36484       result = (float)(arg1)->GetWidthForHeight(arg2);
36485     } catch (std::out_of_range& e) {
36486       {
36487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36488       };
36489     } catch (std::exception& e) {
36490       {
36491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36492       };
36493     } catch (Dali::DaliException e) {
36494       {
36495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36496       };
36497     } catch (...) {
36498       {
36499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36500       };
36501     }
36502   }
36503
36504   jresult = result;
36505   return jresult;
36506 }
36507
36508
36509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36510   float jresult ;
36511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36512   Dali::Dimension::Type arg2 ;
36513   float result;
36514
36515   arg1 = (Dali::Actor *)jarg1;
36516   arg2 = (Dali::Dimension::Type)jarg2;
36517   {
36518     try {
36519       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36520     } catch (std::out_of_range& e) {
36521       {
36522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36523       };
36524     } catch (std::exception& e) {
36525       {
36526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36527       };
36528     } catch (Dali::DaliException e) {
36529       {
36530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36531       };
36532     } catch (...) {
36533       {
36534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36535       };
36536     }
36537   }
36538
36539   jresult = result;
36540   return jresult;
36541 }
36542
36543
36544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36546   Dali::Padding *arg2 = 0 ;
36547
36548   arg1 = (Dali::Actor *)jarg1;
36549   arg2 = (Dali::Padding *)jarg2;
36550   if (!arg2) {
36551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36552     return ;
36553   }
36554   {
36555     try {
36556       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36557     } catch (std::out_of_range& e) {
36558       {
36559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (std::exception& e) {
36562       {
36563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36564       };
36565     } catch (Dali::DaliException e) {
36566       {
36567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36572       };
36573     }
36574   }
36575
36576 }
36577
36578
36579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36580   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36581   Dali::Padding *arg2 = 0 ;
36582
36583   arg1 = (Dali::Actor *)jarg1;
36584   arg2 = (Dali::Padding *)jarg2;
36585   if (!arg2) {
36586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36587     return ;
36588   }
36589   {
36590     try {
36591       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36592     } catch (std::out_of_range& e) {
36593       {
36594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36595       };
36596     } catch (std::exception& e) {
36597       {
36598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36599       };
36600     } catch (Dali::DaliException e) {
36601       {
36602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36603       };
36604     } catch (...) {
36605       {
36606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36607       };
36608     }
36609   }
36610
36611 }
36612
36613
36614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36616   Dali::Vector2 *arg2 = 0 ;
36617
36618   arg1 = (Dali::Actor *)jarg1;
36619   arg2 = (Dali::Vector2 *)jarg2;
36620   if (!arg2) {
36621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36622     return ;
36623   }
36624   {
36625     try {
36626       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36627     } catch (std::out_of_range& e) {
36628       {
36629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36630       };
36631     } catch (std::exception& e) {
36632       {
36633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36634       };
36635     } catch (Dali::DaliException e) {
36636       {
36637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36638       };
36639     } catch (...) {
36640       {
36641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36642       };
36643     }
36644   }
36645
36646 }
36647
36648
36649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36650   void * jresult ;
36651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36652   Dali::Vector2 result;
36653
36654   arg1 = (Dali::Actor *)jarg1;
36655   {
36656     try {
36657       result = (arg1)->GetMinimumSize();
36658     } catch (std::out_of_range& e) {
36659       {
36660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36661       };
36662     } catch (std::exception& e) {
36663       {
36664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (Dali::DaliException e) {
36667       {
36668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36669       };
36670     } catch (...) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36673       };
36674     }
36675   }
36676
36677   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36678   return jresult;
36679 }
36680
36681
36682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36684   Dali::Vector2 *arg2 = 0 ;
36685
36686   arg1 = (Dali::Actor *)jarg1;
36687   arg2 = (Dali::Vector2 *)jarg2;
36688   if (!arg2) {
36689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36690     return ;
36691   }
36692   {
36693     try {
36694       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36695     } catch (std::out_of_range& e) {
36696       {
36697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36698       };
36699     } catch (std::exception& e) {
36700       {
36701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36702       };
36703     } catch (Dali::DaliException e) {
36704       {
36705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36706       };
36707     } catch (...) {
36708       {
36709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36710       };
36711     }
36712   }
36713
36714 }
36715
36716
36717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36718   void * jresult ;
36719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36720   Dali::Vector2 result;
36721
36722   arg1 = (Dali::Actor *)jarg1;
36723   {
36724     try {
36725       result = (arg1)->GetMaximumSize();
36726     } catch (std::out_of_range& e) {
36727       {
36728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36729       };
36730     } catch (std::exception& e) {
36731       {
36732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (Dali::DaliException e) {
36735       {
36736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36737       };
36738     } catch (...) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36741       };
36742     }
36743   }
36744
36745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36746   return jresult;
36747 }
36748
36749
36750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36751   int jresult ;
36752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36753   int result;
36754
36755   arg1 = (Dali::Actor *)jarg1;
36756   {
36757     try {
36758       result = (int)(arg1)->GetHierarchyDepth();
36759       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36760     } catch (std::out_of_range& e) {
36761       {
36762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36763       };
36764     } catch (std::exception& e) {
36765       {
36766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36767       };
36768     } catch (Dali::DaliException e) {
36769       {
36770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36771       };
36772     } catch (...) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36775       };
36776     }
36777   }
36778
36779   jresult = result;
36780   return jresult;
36781 }
36782
36783
36784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36785   unsigned int jresult ;
36786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36787   Dali::Renderer *arg2 = 0 ;
36788   unsigned int result;
36789
36790   arg1 = (Dali::Actor *)jarg1;
36791   arg2 = (Dali::Renderer *)jarg2;
36792   if (!arg2) {
36793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36794     return 0;
36795   }
36796   {
36797     try {
36798       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (Dali::DaliException e) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36810       };
36811     } catch (...) {
36812       {
36813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36814       };
36815     }
36816   }
36817
36818   jresult = result;
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36824   unsigned int jresult ;
36825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36826   unsigned int result;
36827
36828   arg1 = (Dali::Actor *)jarg1;
36829   {
36830     try {
36831       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36832     } catch (std::out_of_range& e) {
36833       {
36834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (std::exception& e) {
36837       {
36838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36839       };
36840     } catch (Dali::DaliException e) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36843       };
36844     } catch (...) {
36845       {
36846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36847       };
36848     }
36849   }
36850
36851   jresult = result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36857   void * jresult ;
36858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36859   unsigned int arg2 ;
36860   Dali::Renderer result;
36861
36862   arg1 = (Dali::Actor *)jarg1;
36863   arg2 = (unsigned int)jarg2;
36864   {
36865     try {
36866       result = (arg1)->GetRendererAt(arg2);
36867     } catch (std::out_of_range& e) {
36868       {
36869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36870       };
36871     } catch (std::exception& e) {
36872       {
36873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (Dali::DaliException e) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36878       };
36879     } catch (...) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36882       };
36883     }
36884   }
36885
36886   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36887   return jresult;
36888 }
36889
36890
36891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36893   Dali::Renderer *arg2 = 0 ;
36894
36895   arg1 = (Dali::Actor *)jarg1;
36896   arg2 = (Dali::Renderer *)jarg2;
36897   if (!arg2) {
36898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36899     return ;
36900   }
36901   {
36902     try {
36903       (arg1)->RemoveRenderer(*arg2);
36904     } catch (std::out_of_range& e) {
36905       {
36906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36907       };
36908     } catch (std::exception& e) {
36909       {
36910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (Dali::DaliException e) {
36913       {
36914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36919       };
36920     }
36921   }
36922
36923 }
36924
36925
36926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   unsigned int arg2 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   arg2 = (unsigned int)jarg2;
36932   {
36933     try {
36934       (arg1)->RemoveRenderer(arg2);
36935     } catch (std::out_of_range& e) {
36936       {
36937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36938       };
36939     } catch (std::exception& e) {
36940       {
36941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36942       };
36943     } catch (Dali::DaliException e) {
36944       {
36945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36946       };
36947     } catch (...) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36950       };
36951     }
36952   }
36953
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36958   void * jresult ;
36959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36960   Dali::Actor::TouchSignalType *result = 0 ;
36961
36962   arg1 = (Dali::Actor *)jarg1;
36963   {
36964     try {
36965       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36966     } catch (std::out_of_range& e) {
36967       {
36968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36969       };
36970     } catch (std::exception& e) {
36971       {
36972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36973       };
36974     } catch (Dali::DaliException e) {
36975       {
36976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36977       };
36978     } catch (...) {
36979       {
36980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36981       };
36982     }
36983   }
36984
36985   jresult = (void *)result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36991   void * jresult ;
36992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36993   Dali::Actor::TouchDataSignalType *result = 0 ;
36994
36995   arg1 = (Dali::Actor *)jarg1;
36996   {
36997     try {
36998       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37006       };
37007     } catch (Dali::DaliException e) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37010       };
37011     } catch (...) {
37012       {
37013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37014       };
37015     }
37016   }
37017
37018   jresult = (void *)result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37024   void * jresult ;
37025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37026   Dali::Actor::HoverSignalType *result = 0 ;
37027
37028   arg1 = (Dali::Actor *)jarg1;
37029   {
37030     try {
37031       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37032     } catch (std::out_of_range& e) {
37033       {
37034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37035       };
37036     } catch (std::exception& e) {
37037       {
37038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37039       };
37040     } catch (Dali::DaliException e) {
37041       {
37042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37043       };
37044     } catch (...) {
37045       {
37046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37047       };
37048     }
37049   }
37050
37051   jresult = (void *)result;
37052   return jresult;
37053 }
37054
37055
37056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37057   void * jresult ;
37058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37059   Dali::Actor::WheelEventSignalType *result = 0 ;
37060
37061   arg1 = (Dali::Actor *)jarg1;
37062   {
37063     try {
37064       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37065     } catch (std::out_of_range& e) {
37066       {
37067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (std::exception& e) {
37070       {
37071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37072       };
37073     } catch (Dali::DaliException e) {
37074       {
37075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37076       };
37077     } catch (...) {
37078       {
37079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37080       };
37081     }
37082   }
37083
37084   jresult = (void *)result;
37085   return jresult;
37086 }
37087
37088
37089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37090   void * jresult ;
37091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37092   Dali::Actor::OnStageSignalType *result = 0 ;
37093
37094   arg1 = (Dali::Actor *)jarg1;
37095   {
37096     try {
37097       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37098     } catch (std::out_of_range& e) {
37099       {
37100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37101       };
37102     } catch (std::exception& e) {
37103       {
37104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37105       };
37106     } catch (Dali::DaliException e) {
37107       {
37108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37109       };
37110     } catch (...) {
37111       {
37112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37113       };
37114     }
37115   }
37116
37117   jresult = (void *)result;
37118   return jresult;
37119 }
37120
37121
37122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37123   void * jresult ;
37124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37125   Dali::Actor::OffStageSignalType *result = 0 ;
37126
37127   arg1 = (Dali::Actor *)jarg1;
37128   {
37129     try {
37130       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37131     } catch (std::out_of_range& e) {
37132       {
37133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37134       };
37135     } catch (std::exception& e) {
37136       {
37137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (Dali::DaliException e) {
37140       {
37141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149
37150   jresult = (void *)result;
37151   return jresult;
37152 }
37153
37154
37155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37156   void * jresult ;
37157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37158   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37159
37160   arg1 = (Dali::Actor *)jarg1;
37161   {
37162     try {
37163       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37164     } catch (std::out_of_range& e) {
37165       {
37166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37167       };
37168     } catch (std::exception& e) {
37169       {
37170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37171       };
37172     } catch (Dali::DaliException e) {
37173       {
37174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37175       };
37176     } catch (...) {
37177       {
37178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37179       };
37180     }
37181   }
37182
37183   jresult = (void *)result;
37184   return jresult;
37185 }
37186
37187
37188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37189   Dali::Actor *arg1 = 0 ;
37190
37191   arg1 = (Dali::Actor *)jarg1;
37192   if (!arg1) {
37193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37194     return ;
37195   }
37196   {
37197     try {
37198       Dali::UnparentAndReset(*arg1);
37199     } catch (std::out_of_range& e) {
37200       {
37201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37202       };
37203     } catch (std::exception& e) {
37204       {
37205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37206       };
37207     } catch (Dali::DaliException e) {
37208       {
37209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37210       };
37211     } catch (...) {
37212       {
37213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37214       };
37215     }
37216   }
37217
37218 }
37219
37220
37221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37222   int jresult ;
37223   int result;
37224
37225   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37226   jresult = (int)result;
37227   return jresult;
37228 }
37229
37230
37231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37232   int jresult ;
37233   int result;
37234
37235   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37236   jresult = (int)result;
37237   return jresult;
37238 }
37239
37240
37241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37242   int jresult ;
37243   int result;
37244
37245   result = (int)Dali::Layer::Property::BEHAVIOR;
37246   jresult = (int)result;
37247   return jresult;
37248 }
37249
37250
37251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37252   void * jresult ;
37253   Dali::Layer::Property *result = 0 ;
37254
37255   {
37256     try {
37257       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37258     } catch (std::out_of_range& e) {
37259       {
37260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37261       };
37262     } catch (std::exception& e) {
37263       {
37264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37265       };
37266     } catch (Dali::DaliException e) {
37267       {
37268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37269       };
37270     } catch (...) {
37271       {
37272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37273       };
37274     }
37275   }
37276
37277   jresult = (void *)result;
37278   return jresult;
37279 }
37280
37281
37282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37283   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37284
37285   arg1 = (Dali::Layer::Property *)jarg1;
37286   {
37287     try {
37288       delete arg1;
37289     } catch (std::out_of_range& e) {
37290       {
37291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37292       };
37293     } catch (std::exception& e) {
37294       {
37295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37296       };
37297     } catch (Dali::DaliException e) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37304       };
37305     }
37306   }
37307
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37312   void * jresult ;
37313   Dali::Layer *result = 0 ;
37314
37315   {
37316     try {
37317       result = (Dali::Layer *)new Dali::Layer();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (Dali::DaliException e) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37329       };
37330     } catch (...) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37333       };
37334     }
37335   }
37336
37337   jresult = (void *)result;
37338   return jresult;
37339 }
37340
37341
37342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37343   void * jresult ;
37344   Dali::Layer result;
37345
37346   {
37347     try {
37348       result = Dali::Layer::New();
37349     } catch (std::out_of_range& e) {
37350       {
37351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (std::exception& e) {
37354       {
37355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37356       };
37357     } catch (Dali::DaliException e) {
37358       {
37359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37360       };
37361     } catch (...) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37364       };
37365     }
37366   }
37367
37368   jresult = new Dali::Layer((const Dali::Layer &)result);
37369   return jresult;
37370 }
37371
37372
37373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37374   void * jresult ;
37375   Dali::BaseHandle arg1 ;
37376   Dali::BaseHandle *argp1 ;
37377   Dali::Layer result;
37378
37379   argp1 = (Dali::BaseHandle *)jarg1;
37380   if (!argp1) {
37381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37382     return 0;
37383   }
37384   arg1 = *argp1;
37385   {
37386     try {
37387       result = Dali::Layer::DownCast(arg1);
37388     } catch (std::out_of_range& e) {
37389       {
37390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37391       };
37392     } catch (std::exception& e) {
37393       {
37394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37395       };
37396     } catch (Dali::DaliException e) {
37397       {
37398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37399       };
37400     } catch (...) {
37401       {
37402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37403       };
37404     }
37405   }
37406
37407   jresult = new Dali::Layer((const Dali::Layer &)result);
37408   return jresult;
37409 }
37410
37411
37412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37413   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37414
37415   arg1 = (Dali::Layer *)jarg1;
37416   {
37417     try {
37418       delete arg1;
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37426       };
37427     } catch (Dali::DaliException e) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37430       };
37431     } catch (...) {
37432       {
37433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37434       };
37435     }
37436   }
37437
37438 }
37439
37440
37441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37442   void * jresult ;
37443   Dali::Layer *arg1 = 0 ;
37444   Dali::Layer *result = 0 ;
37445
37446   arg1 = (Dali::Layer *)jarg1;
37447   if (!arg1) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37449     return 0;
37450   }
37451   {
37452     try {
37453       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37454     } catch (std::out_of_range& e) {
37455       {
37456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37457       };
37458     } catch (std::exception& e) {
37459       {
37460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37461       };
37462     } catch (Dali::DaliException e) {
37463       {
37464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37465       };
37466     } catch (...) {
37467       {
37468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37469       };
37470     }
37471   }
37472
37473   jresult = (void *)result;
37474   return jresult;
37475 }
37476
37477
37478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37479   void * jresult ;
37480   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37481   Dali::Layer *arg2 = 0 ;
37482   Dali::Layer *result = 0 ;
37483
37484   arg1 = (Dali::Layer *)jarg1;
37485   arg2 = (Dali::Layer *)jarg2;
37486   if (!arg2) {
37487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37488     return 0;
37489   }
37490   {
37491     try {
37492       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37493     } catch (std::out_of_range& e) {
37494       {
37495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37496       };
37497     } catch (std::exception& e) {
37498       {
37499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (Dali::DaliException e) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37504       };
37505     } catch (...) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37508       };
37509     }
37510   }
37511
37512   jresult = (void *)result;
37513   return jresult;
37514 }
37515
37516
37517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37518   unsigned int jresult ;
37519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37520   unsigned int result;
37521
37522   arg1 = (Dali::Layer *)jarg1;
37523   {
37524     try {
37525       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37533       };
37534     } catch (Dali::DaliException e) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37537       };
37538     } catch (...) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37541       };
37542     }
37543   }
37544
37545   jresult = result;
37546   return jresult;
37547 }
37548
37549
37550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37551   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37552
37553   arg1 = (Dali::Layer *)jarg1;
37554   {
37555     try {
37556       (arg1)->Raise();
37557     } catch (std::out_of_range& e) {
37558       {
37559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37560       };
37561     } catch (std::exception& e) {
37562       {
37563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37564       };
37565     } catch (Dali::DaliException e) {
37566       {
37567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37568       };
37569     } catch (...) {
37570       {
37571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37572       };
37573     }
37574   }
37575
37576 }
37577
37578
37579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37580   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37581
37582   arg1 = (Dali::Layer *)jarg1;
37583   {
37584     try {
37585       (arg1)->Lower();
37586     } catch (std::out_of_range& e) {
37587       {
37588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37589       };
37590     } catch (std::exception& e) {
37591       {
37592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37593       };
37594     } catch (Dali::DaliException e) {
37595       {
37596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37597       };
37598     } catch (...) {
37599       {
37600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37601       };
37602     }
37603   }
37604
37605 }
37606
37607
37608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37609   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37610   Dali::Layer arg2 ;
37611   Dali::Layer *argp2 ;
37612
37613   arg1 = (Dali::Layer *)jarg1;
37614   argp2 = (Dali::Layer *)jarg2;
37615   if (!argp2) {
37616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37617     return ;
37618   }
37619   arg2 = *argp2;
37620   {
37621     try {
37622       (arg1)->RaiseAbove(arg2);
37623     } catch (std::out_of_range& e) {
37624       {
37625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37626       };
37627     } catch (std::exception& e) {
37628       {
37629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37630       };
37631     } catch (Dali::DaliException e) {
37632       {
37633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37638       };
37639     }
37640   }
37641
37642 }
37643
37644
37645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37646   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37647   Dali::Layer arg2 ;
37648   Dali::Layer *argp2 ;
37649
37650   arg1 = (Dali::Layer *)jarg1;
37651   argp2 = (Dali::Layer *)jarg2;
37652   if (!argp2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37654     return ;
37655   }
37656   arg2 = *argp2;
37657   {
37658     try {
37659       (arg1)->LowerBelow(arg2);
37660     } catch (std::out_of_range& e) {
37661       {
37662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (std::exception& e) {
37665       {
37666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37667       };
37668     } catch (Dali::DaliException e) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37671       };
37672     } catch (...) {
37673       {
37674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37675       };
37676     }
37677   }
37678
37679 }
37680
37681
37682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37683   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   {
37687     try {
37688       (arg1)->RaiseToTop();
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37696       };
37697     } catch (Dali::DaliException e) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37704       };
37705     }
37706   }
37707
37708 }
37709
37710
37711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37712   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37713
37714   arg1 = (Dali::Layer *)jarg1;
37715   {
37716     try {
37717       (arg1)->LowerToBottom();
37718     } catch (std::out_of_range& e) {
37719       {
37720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37721       };
37722     } catch (std::exception& e) {
37723       {
37724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37725       };
37726     } catch (Dali::DaliException e) {
37727       {
37728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37729       };
37730     } catch (...) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37733       };
37734     }
37735   }
37736
37737 }
37738
37739
37740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37741   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37742   Dali::Layer arg2 ;
37743   Dali::Layer *argp2 ;
37744
37745   arg1 = (Dali::Layer *)jarg1;
37746   argp2 = (Dali::Layer *)jarg2;
37747   if (!argp2) {
37748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37749     return ;
37750   }
37751   arg2 = *argp2;
37752   {
37753     try {
37754       (arg1)->MoveAbove(arg2);
37755     } catch (std::out_of_range& e) {
37756       {
37757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37758       };
37759     } catch (std::exception& e) {
37760       {
37761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37762       };
37763     } catch (Dali::DaliException e) {
37764       {
37765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37766       };
37767     } catch (...) {
37768       {
37769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37770       };
37771     }
37772   }
37773
37774 }
37775
37776
37777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37778   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37779   Dali::Layer arg2 ;
37780   Dali::Layer *argp2 ;
37781
37782   arg1 = (Dali::Layer *)jarg1;
37783   argp2 = (Dali::Layer *)jarg2;
37784   if (!argp2) {
37785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37786     return ;
37787   }
37788   arg2 = *argp2;
37789   {
37790     try {
37791       (arg1)->MoveBelow(arg2);
37792     } catch (std::out_of_range& e) {
37793       {
37794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37795       };
37796     } catch (std::exception& e) {
37797       {
37798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37799       };
37800     } catch (Dali::DaliException e) {
37801       {
37802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37803       };
37804     } catch (...) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37807       };
37808     }
37809   }
37810
37811 }
37812
37813
37814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   Dali::Layer::Behavior arg2 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   arg2 = (Dali::Layer::Behavior)jarg2;
37820   {
37821     try {
37822       (arg1)->SetBehavior(arg2);
37823     } catch (std::out_of_range& e) {
37824       {
37825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (std::exception& e) {
37828       {
37829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37830       };
37831     } catch (Dali::DaliException e) {
37832       {
37833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37838       };
37839     }
37840   }
37841
37842 }
37843
37844
37845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37846   int jresult ;
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   Dali::Layer::Behavior result;
37849
37850   arg1 = (Dali::Layer *)jarg1;
37851   {
37852     try {
37853       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37854     } catch (std::out_of_range& e) {
37855       {
37856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37857       };
37858     } catch (std::exception& e) {
37859       {
37860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37861       };
37862     } catch (Dali::DaliException e) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37865       };
37866     } catch (...) {
37867       {
37868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37869       };
37870     }
37871   }
37872
37873   jresult = (int)result;
37874   return jresult;
37875 }
37876
37877
37878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37879   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37880   bool arg2 ;
37881
37882   arg1 = (Dali::Layer *)jarg1;
37883   arg2 = jarg2 ? true : false;
37884   {
37885     try {
37886       (arg1)->SetClipping(arg2);
37887     } catch (std::out_of_range& e) {
37888       {
37889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37890       };
37891     } catch (std::exception& e) {
37892       {
37893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (Dali::DaliException e) {
37896       {
37897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905
37906 }
37907
37908
37909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37910   unsigned int jresult ;
37911   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37912   bool result;
37913
37914   arg1 = (Dali::Layer *)jarg1;
37915   {
37916     try {
37917       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37918     } catch (std::out_of_range& e) {
37919       {
37920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37921       };
37922     } catch (std::exception& e) {
37923       {
37924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37925       };
37926     } catch (Dali::DaliException e) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37929       };
37930     } catch (...) {
37931       {
37932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37933       };
37934     }
37935   }
37936
37937   jresult = result;
37938   return jresult;
37939 }
37940
37941
37942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37943   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37944   int arg2 ;
37945   int arg3 ;
37946   int arg4 ;
37947   int arg5 ;
37948
37949   arg1 = (Dali::Layer *)jarg1;
37950   arg2 = (int)jarg2;
37951   arg3 = (int)jarg3;
37952   arg4 = (int)jarg4;
37953   arg5 = (int)jarg5;
37954   {
37955     try {
37956       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37957     } catch (std::out_of_range& e) {
37958       {
37959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37960       };
37961     } catch (std::exception& e) {
37962       {
37963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37964       };
37965     } catch (Dali::DaliException e) {
37966       {
37967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37968       };
37969     } catch (...) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37972       };
37973     }
37974   }
37975
37976 }
37977
37978
37979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37980   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37981   Dali::ClippingBox arg2 ;
37982   Dali::ClippingBox *argp2 ;
37983
37984   arg1 = (Dali::Layer *)jarg1;
37985   argp2 = (Dali::ClippingBox *)jarg2;
37986   if (!argp2) {
37987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37988     return ;
37989   }
37990   arg2 = *argp2;
37991   {
37992     try {
37993       (arg1)->SetClippingBox(arg2);
37994     } catch (std::out_of_range& e) {
37995       {
37996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37997       };
37998     } catch (std::exception& e) {
37999       {
38000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38001       };
38002     } catch (Dali::DaliException e) {
38003       {
38004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38005       };
38006     } catch (...) {
38007       {
38008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38009       };
38010     }
38011   }
38012
38013 }
38014
38015
38016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38017   void * jresult ;
38018   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38019   Dali::ClippingBox result;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   {
38023     try {
38024       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (Dali::DaliException e) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38040       };
38041     }
38042   }
38043
38044   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38045   return jresult;
38046 }
38047
38048
38049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38050   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38051   bool arg2 ;
38052
38053   arg1 = (Dali::Layer *)jarg1;
38054   arg2 = jarg2 ? true : false;
38055   {
38056     try {
38057       (arg1)->SetDepthTestDisabled(arg2);
38058     } catch (std::out_of_range& e) {
38059       {
38060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38061       };
38062     } catch (std::exception& e) {
38063       {
38064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38065       };
38066     } catch (Dali::DaliException e) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38069       };
38070     } catch (...) {
38071       {
38072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38073       };
38074     }
38075   }
38076
38077 }
38078
38079
38080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38081   unsigned int jresult ;
38082   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38083   bool result;
38084
38085   arg1 = (Dali::Layer *)jarg1;
38086   {
38087     try {
38088       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38089     } catch (std::out_of_range& e) {
38090       {
38091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (std::exception& e) {
38094       {
38095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (Dali::DaliException e) {
38098       {
38099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38100       };
38101     } catch (...) {
38102       {
38103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38104       };
38105     }
38106   }
38107
38108   jresult = result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38114   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38115   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38116
38117   arg1 = (Dali::Layer *)jarg1;
38118   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38119   {
38120     try {
38121       (arg1)->SetSortFunction(arg2);
38122     } catch (std::out_of_range& e) {
38123       {
38124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38125       };
38126     } catch (std::exception& e) {
38127       {
38128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (Dali::DaliException e) {
38131       {
38132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140
38141 }
38142
38143
38144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38146   bool arg2 ;
38147
38148   arg1 = (Dali::Layer *)jarg1;
38149   arg2 = jarg2 ? true : false;
38150   {
38151     try {
38152       (arg1)->SetTouchConsumed(arg2);
38153     } catch (std::out_of_range& e) {
38154       {
38155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38156       };
38157     } catch (std::exception& e) {
38158       {
38159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38160       };
38161     } catch (Dali::DaliException e) {
38162       {
38163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38164       };
38165     } catch (...) {
38166       {
38167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38168       };
38169     }
38170   }
38171
38172 }
38173
38174
38175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38176   unsigned int jresult ;
38177   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38178   bool result;
38179
38180   arg1 = (Dali::Layer *)jarg1;
38181   {
38182     try {
38183       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38184     } catch (std::out_of_range& e) {
38185       {
38186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38187       };
38188     } catch (std::exception& e) {
38189       {
38190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38191       };
38192     } catch (Dali::DaliException e) {
38193       {
38194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38195       };
38196     } catch (...) {
38197       {
38198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38199       };
38200     }
38201   }
38202
38203   jresult = result;
38204   return jresult;
38205 }
38206
38207
38208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38209   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38210   bool arg2 ;
38211
38212   arg1 = (Dali::Layer *)jarg1;
38213   arg2 = jarg2 ? true : false;
38214   {
38215     try {
38216       (arg1)->SetHoverConsumed(arg2);
38217     } catch (std::out_of_range& e) {
38218       {
38219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38220       };
38221     } catch (std::exception& e) {
38222       {
38223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38224       };
38225     } catch (Dali::DaliException e) {
38226       {
38227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38228       };
38229     } catch (...) {
38230       {
38231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38232       };
38233     }
38234   }
38235
38236 }
38237
38238
38239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38240   unsigned int jresult ;
38241   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38242   bool result;
38243
38244   arg1 = (Dali::Layer *)jarg1;
38245   {
38246     try {
38247       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (Dali::DaliException e) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38259       };
38260     } catch (...) {
38261       {
38262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38263       };
38264     }
38265   }
38266
38267   jresult = result;
38268   return jresult;
38269 }
38270
38271
38272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38273   void * jresult ;
38274   Dali::Vector4 *result = 0 ;
38275
38276   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38277   jresult = (void *)result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38283   void * jresult ;
38284   Dali::Vector4 *result = 0 ;
38285
38286   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38287   jresult = (void *)result;
38288   return jresult;
38289 }
38290
38291
38292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38293   void * jresult ;
38294   Dali::Stage *result = 0 ;
38295
38296   {
38297     try {
38298       result = (Dali::Stage *)new Dali::Stage();
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (Dali::DaliException e) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38314       };
38315     }
38316   }
38317
38318   jresult = (void *)result;
38319   return jresult;
38320 }
38321
38322
38323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38324   void * jresult ;
38325   Dali::Stage result;
38326
38327   {
38328     try {
38329       result = Dali::Stage::GetCurrent();
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348
38349   jresult = new Dali::Stage((const Dali::Stage &)result);
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38355   unsigned int jresult ;
38356   bool result;
38357
38358   {
38359     try {
38360       result = (bool)Dali::Stage::IsInstalled();
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (Dali::DaliException e) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38372       };
38373     } catch (...) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38376       };
38377     }
38378   }
38379
38380   jresult = result;
38381   return jresult;
38382 }
38383
38384
38385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38386   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38387
38388   arg1 = (Dali::Stage *)jarg1;
38389   {
38390     try {
38391       delete arg1;
38392     } catch (std::out_of_range& e) {
38393       {
38394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38395       };
38396     } catch (std::exception& e) {
38397       {
38398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38399       };
38400     } catch (Dali::DaliException e) {
38401       {
38402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38403       };
38404     } catch (...) {
38405       {
38406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38407       };
38408     }
38409   }
38410
38411 }
38412
38413
38414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38415   void * jresult ;
38416   Dali::Stage *arg1 = 0 ;
38417   Dali::Stage *result = 0 ;
38418
38419   arg1 = (Dali::Stage *)jarg1;
38420   if (!arg1) {
38421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38422     return 0;
38423   }
38424   {
38425     try {
38426       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38427     } catch (std::out_of_range& e) {
38428       {
38429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38430       };
38431     } catch (std::exception& e) {
38432       {
38433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38434       };
38435     } catch (Dali::DaliException e) {
38436       {
38437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38438       };
38439     } catch (...) {
38440       {
38441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38442       };
38443     }
38444   }
38445
38446   jresult = (void *)result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38452   void * jresult ;
38453   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38454   Dali::Stage *arg2 = 0 ;
38455   Dali::Stage *result = 0 ;
38456
38457   arg1 = (Dali::Stage *)jarg1;
38458   arg2 = (Dali::Stage *)jarg2;
38459   if (!arg2) {
38460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38461     return 0;
38462   }
38463   {
38464     try {
38465       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38466     } catch (std::out_of_range& e) {
38467       {
38468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38469       };
38470     } catch (std::exception& e) {
38471       {
38472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38473       };
38474     } catch (Dali::DaliException e) {
38475       {
38476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38477       };
38478     } catch (...) {
38479       {
38480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38481       };
38482     }
38483   }
38484
38485   jresult = (void *)result;
38486   return jresult;
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38491   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38492   Dali::Actor *arg2 = 0 ;
38493
38494   arg1 = (Dali::Stage *)jarg1;
38495   arg2 = (Dali::Actor *)jarg2;
38496   if (!arg2) {
38497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38498     return ;
38499   }
38500   {
38501     try {
38502       (arg1)->Add(*arg2);
38503     } catch (std::out_of_range& e) {
38504       {
38505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38506       };
38507     } catch (std::exception& e) {
38508       {
38509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38510       };
38511     } catch (Dali::DaliException e) {
38512       {
38513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38518       };
38519     }
38520   }
38521
38522 }
38523
38524
38525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   Dali::Actor *arg2 = 0 ;
38528
38529   arg1 = (Dali::Stage *)jarg1;
38530   arg2 = (Dali::Actor *)jarg2;
38531   if (!arg2) {
38532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38533     return ;
38534   }
38535   {
38536     try {
38537       (arg1)->Remove(*arg2);
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38545       };
38546     } catch (Dali::DaliException e) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38553       };
38554     }
38555   }
38556
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38561   void * jresult ;
38562   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38563   Dali::Vector2 result;
38564
38565   arg1 = (Dali::Stage *)jarg1;
38566   {
38567     try {
38568       result = ((Dali::Stage const *)arg1)->GetSize();
38569     } catch (std::out_of_range& e) {
38570       {
38571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (std::exception& e) {
38574       {
38575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (Dali::DaliException e) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38580       };
38581     } catch (...) {
38582       {
38583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38584       };
38585     }
38586   }
38587
38588   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38589   return jresult;
38590 }
38591
38592
38593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38594   void * jresult ;
38595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38596   Dali::RenderTaskList result;
38597
38598   arg1 = (Dali::Stage *)jarg1;
38599   {
38600     try {
38601       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38602     } catch (std::out_of_range& e) {
38603       {
38604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (std::exception& e) {
38607       {
38608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (Dali::DaliException e) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38613       };
38614     } catch (...) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38617       };
38618     }
38619   }
38620
38621   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38622   return jresult;
38623 }
38624
38625
38626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38627   unsigned int jresult ;
38628   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38629   unsigned int result;
38630
38631   arg1 = (Dali::Stage *)jarg1;
38632   {
38633     try {
38634       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38635     } catch (std::out_of_range& e) {
38636       {
38637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (std::exception& e) {
38640       {
38641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38642       };
38643     } catch (Dali::DaliException e) {
38644       {
38645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38646       };
38647     } catch (...) {
38648       {
38649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38650       };
38651     }
38652   }
38653
38654   jresult = result;
38655   return jresult;
38656 }
38657
38658
38659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38660   void * jresult ;
38661   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38662   unsigned int arg2 ;
38663   Dali::Layer result;
38664
38665   arg1 = (Dali::Stage *)jarg1;
38666   arg2 = (unsigned int)jarg2;
38667   {
38668     try {
38669       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38670     } catch (std::out_of_range& e) {
38671       {
38672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38673       };
38674     } catch (std::exception& e) {
38675       {
38676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38677       };
38678     } catch (Dali::DaliException e) {
38679       {
38680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38681       };
38682     } catch (...) {
38683       {
38684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38685       };
38686     }
38687   }
38688
38689   jresult = new Dali::Layer((const Dali::Layer &)result);
38690   return jresult;
38691 }
38692
38693
38694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38695   void * jresult ;
38696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38697   Dali::Layer result;
38698
38699   arg1 = (Dali::Stage *)jarg1;
38700   {
38701     try {
38702       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38703     } catch (std::out_of_range& e) {
38704       {
38705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38706       };
38707     } catch (std::exception& e) {
38708       {
38709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38710       };
38711     } catch (Dali::DaliException e) {
38712       {
38713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38714       };
38715     } catch (...) {
38716       {
38717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38718       };
38719     }
38720   }
38721
38722   jresult = new Dali::Layer((const Dali::Layer &)result);
38723   return jresult;
38724 }
38725
38726
38727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38729   Dali::Vector4 arg2 ;
38730   Dali::Vector4 *argp2 ;
38731
38732   arg1 = (Dali::Stage *)jarg1;
38733   argp2 = (Dali::Vector4 *)jarg2;
38734   if (!argp2) {
38735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38736     return ;
38737   }
38738   arg2 = *argp2;
38739   {
38740     try {
38741       (arg1)->SetBackgroundColor(arg2);
38742     } catch (std::out_of_range& e) {
38743       {
38744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38745       };
38746     } catch (std::exception& e) {
38747       {
38748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38749       };
38750     } catch (Dali::DaliException e) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38757       };
38758     }
38759   }
38760
38761 }
38762
38763
38764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38765   void * jresult ;
38766   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38767   Dali::Vector4 result;
38768
38769   arg1 = (Dali::Stage *)jarg1;
38770   {
38771     try {
38772       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38773     } catch (std::out_of_range& e) {
38774       {
38775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38776       };
38777     } catch (std::exception& e) {
38778       {
38779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38780       };
38781     } catch (Dali::DaliException e) {
38782       {
38783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38784       };
38785     } catch (...) {
38786       {
38787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38788       };
38789     }
38790   }
38791
38792   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38793   return jresult;
38794 }
38795
38796
38797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38798   void * jresult ;
38799   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38800   Dali::Vector2 result;
38801
38802   arg1 = (Dali::Stage *)jarg1;
38803   {
38804     try {
38805       result = ((Dali::Stage const *)arg1)->GetDpi();
38806     } catch (std::out_of_range& e) {
38807       {
38808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38809       };
38810     } catch (std::exception& e) {
38811       {
38812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38813       };
38814     } catch (Dali::DaliException e) {
38815       {
38816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38817       };
38818     } catch (...) {
38819       {
38820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38821       };
38822     }
38823   }
38824
38825   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38826   return jresult;
38827 }
38828
38829
38830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38831   void * jresult ;
38832   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38833   Dali::ObjectRegistry result;
38834
38835   arg1 = (Dali::Stage *)jarg1;
38836   {
38837     try {
38838       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38839     } catch (std::out_of_range& e) {
38840       {
38841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38842       };
38843     } catch (std::exception& e) {
38844       {
38845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (Dali::DaliException e) {
38848       {
38849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857
38858   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38859   return jresult;
38860 }
38861
38862
38863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38864   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38865   float arg2 ;
38866
38867   arg1 = (Dali::Stage *)jarg1;
38868   arg2 = (float)jarg2;
38869   {
38870     try {
38871       (arg1)->KeepRendering(arg2);
38872     } catch (std::out_of_range& e) {
38873       {
38874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38875       };
38876     } catch (std::exception& e) {
38877       {
38878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38879       };
38880     } catch (Dali::DaliException e) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38883       };
38884     } catch (...) {
38885       {
38886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38887       };
38888     }
38889   }
38890
38891 }
38892
38893
38894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38895   void * jresult ;
38896   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38897   Dali::Stage::KeyEventSignalType *result = 0 ;
38898
38899   arg1 = (Dali::Stage *)jarg1;
38900   {
38901     try {
38902       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38903     } catch (std::out_of_range& e) {
38904       {
38905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38906       };
38907     } catch (std::exception& e) {
38908       {
38909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (Dali::DaliException e) {
38912       {
38913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921
38922   jresult = (void *)result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38928   void * jresult ;
38929   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38930   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38931
38932   arg1 = (Dali::Stage *)jarg1;
38933   {
38934     try {
38935       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38936     } catch (std::out_of_range& e) {
38937       {
38938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38939       };
38940     } catch (std::exception& e) {
38941       {
38942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38943       };
38944     } catch (Dali::DaliException e) {
38945       {
38946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38947       };
38948     } catch (...) {
38949       {
38950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38951       };
38952     }
38953   }
38954
38955   jresult = (void *)result;
38956   return jresult;
38957 }
38958
38959
38960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38961   void * jresult ;
38962   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38963   Dali::Stage::TouchSignalType *result = 0 ;
38964
38965   arg1 = (Dali::Stage *)jarg1;
38966   {
38967     try {
38968       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38969     } catch (std::out_of_range& e) {
38970       {
38971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38972       };
38973     } catch (std::exception& e) {
38974       {
38975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38976       };
38977     } catch (Dali::DaliException e) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38980       };
38981     } catch (...) {
38982       {
38983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38984       };
38985     }
38986   }
38987
38988   jresult = (void *)result;
38989   return jresult;
38990 }
38991
38992
38993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38994   void * jresult ;
38995   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38996   Dali::Stage::WheelEventSignalType *result = 0 ;
38997
38998   arg1 = (Dali::Stage *)jarg1;
38999   {
39000     try {
39001       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39002     } catch (std::out_of_range& e) {
39003       {
39004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39005       };
39006     } catch (std::exception& e) {
39007       {
39008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39009       };
39010     } catch (Dali::DaliException e) {
39011       {
39012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39013       };
39014     } catch (...) {
39015       {
39016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39017       };
39018     }
39019   }
39020
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39027   void * jresult ;
39028   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39029   Dali::Stage::ContextStatusSignal *result = 0 ;
39030
39031   arg1 = (Dali::Stage *)jarg1;
39032   {
39033     try {
39034       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39035     } catch (std::out_of_range& e) {
39036       {
39037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39038       };
39039     } catch (std::exception& e) {
39040       {
39041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39042       };
39043     } catch (Dali::DaliException e) {
39044       {
39045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39046       };
39047     } catch (...) {
39048       {
39049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39050       };
39051     }
39052   }
39053
39054   jresult = (void *)result;
39055   return jresult;
39056 }
39057
39058
39059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39060   void * jresult ;
39061   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39062   Dali::Stage::ContextStatusSignal *result = 0 ;
39063
39064   arg1 = (Dali::Stage *)jarg1;
39065   {
39066     try {
39067       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39068     } catch (std::out_of_range& e) {
39069       {
39070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39071       };
39072     } catch (std::exception& e) {
39073       {
39074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39075       };
39076     } catch (Dali::DaliException e) {
39077       {
39078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39079       };
39080     } catch (...) {
39081       {
39082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39083       };
39084     }
39085   }
39086
39087   jresult = (void *)result;
39088   return jresult;
39089 }
39090
39091
39092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39093   void * jresult ;
39094   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39095   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39096
39097   arg1 = (Dali::Stage *)jarg1;
39098   {
39099     try {
39100       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39101     } catch (std::out_of_range& e) {
39102       {
39103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39104       };
39105     } catch (std::exception& e) {
39106       {
39107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (Dali::DaliException e) {
39110       {
39111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119
39120   jresult = (void *)result;
39121   return jresult;
39122 }
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39125   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39126   Dali::DevelStage::Rendering arg2 ;
39127
39128   arg1 = (Dali::Stage *)jarg1;
39129   arg2 = (Dali::DevelStage::Rendering)jarg2;
39130   {
39131     try {
39132       DevelStage::SetRenderingBehavior(*arg1,arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (Dali::DaliException e) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39144       };
39145     } catch (...) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39148       };
39149     }
39150   }
39151
39152 }
39153
39154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39155
39156   int jresult ;
39157   int result ;
39158   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39159
39160   arg1 = (Dali::Stage *)jarg1;
39161   {
39162     try {
39163       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39164     } catch (std::out_of_range& e) {
39165       {
39166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39167       };
39168     } catch (std::exception& e) {
39169       {
39170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39171       };
39172     } catch (Dali::DaliException e) {
39173       {
39174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39175       };
39176     } catch (...) {
39177       {
39178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39179       };
39180     }
39181   }
39182
39183   jresult = result;
39184   return jresult;
39185 }
39186
39187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39188   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39189
39190   arg1 = (Dali::RelayoutContainer *)jarg1;
39191   {
39192     try {
39193       delete arg1;
39194     } catch (std::out_of_range& e) {
39195       {
39196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (std::exception& e) {
39199       {
39200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39201       };
39202     } catch (Dali::DaliException e) {
39203       {
39204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39205       };
39206     } catch (...) {
39207       {
39208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39209       };
39210     }
39211   }
39212
39213 }
39214
39215
39216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39217   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39218   Dali::Actor *arg2 = 0 ;
39219   Dali::Vector2 *arg3 = 0 ;
39220
39221   arg1 = (Dali::RelayoutContainer *)jarg1;
39222   arg2 = (Dali::Actor *)jarg2;
39223   if (!arg2) {
39224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39225     return ;
39226   }
39227   arg3 = (Dali::Vector2 *)jarg3;
39228   if (!arg3) {
39229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39230     return ;
39231   }
39232   {
39233     try {
39234       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39235     } catch (std::out_of_range& e) {
39236       {
39237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39238       };
39239     } catch (std::exception& e) {
39240       {
39241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (Dali::DaliException e) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39246       };
39247     } catch (...) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39250       };
39251     }
39252   }
39253
39254 }
39255
39256
39257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39258   void * jresult ;
39259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39260   Dali::CustomActor result;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   {
39264     try {
39265       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39273       };
39274     } catch (Dali::DaliException e) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39281       };
39282     }
39283   }
39284
39285   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39286   return jresult;
39287 }
39288
39289
39290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39291   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39292   int arg2 ;
39293
39294   arg1 = (Dali::CustomActorImpl *)jarg1;
39295   arg2 = (int)jarg2;
39296   {
39297     try {
39298       (arg1)->OnStageConnection(arg2);
39299     } catch (std::out_of_range& e) {
39300       {
39301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39302       };
39303     } catch (std::exception& e) {
39304       {
39305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39306       };
39307     } catch (Dali::DaliException e) {
39308       {
39309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39310       };
39311     } catch (...) {
39312       {
39313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39314       };
39315     }
39316   }
39317
39318 }
39319
39320
39321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39322   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39323
39324   arg1 = (Dali::CustomActorImpl *)jarg1;
39325   {
39326     try {
39327       (arg1)->OnStageDisconnection();
39328     } catch (std::out_of_range& e) {
39329       {
39330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39331       };
39332     } catch (std::exception& e) {
39333       {
39334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39335       };
39336     } catch (Dali::DaliException e) {
39337       {
39338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39339       };
39340     } catch (...) {
39341       {
39342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39343       };
39344     }
39345   }
39346
39347 }
39348
39349
39350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39351   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39352   Dali::Actor *arg2 = 0 ;
39353
39354   arg1 = (Dali::CustomActorImpl *)jarg1;
39355   arg2 = (Dali::Actor *)jarg2;
39356   if (!arg2) {
39357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39358     return ;
39359   }
39360   {
39361     try {
39362       (arg1)->OnChildAdd(*arg2);
39363     } catch (std::out_of_range& e) {
39364       {
39365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39366       };
39367     } catch (std::exception& e) {
39368       {
39369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39370       };
39371     } catch (Dali::DaliException e) {
39372       {
39373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39374       };
39375     } catch (...) {
39376       {
39377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39378       };
39379     }
39380   }
39381
39382 }
39383
39384
39385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39386   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39387   Dali::Actor *arg2 = 0 ;
39388
39389   arg1 = (Dali::CustomActorImpl *)jarg1;
39390   arg2 = (Dali::Actor *)jarg2;
39391   if (!arg2) {
39392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39393     return ;
39394   }
39395   {
39396     try {
39397       (arg1)->OnChildRemove(*arg2);
39398     } catch (std::out_of_range& e) {
39399       {
39400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39401       };
39402     } catch (std::exception& e) {
39403       {
39404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39405       };
39406     } catch (Dali::DaliException e) {
39407       {
39408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39409       };
39410     } catch (...) {
39411       {
39412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39413       };
39414     }
39415   }
39416
39417 }
39418
39419
39420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39422   Dali::Property::Index arg2 ;
39423   Dali::Property::Value arg3 ;
39424   Dali::Property::Value *argp3 ;
39425
39426   arg1 = (Dali::CustomActorImpl *)jarg1;
39427   arg2 = (Dali::Property::Index)jarg2;
39428   argp3 = (Dali::Property::Value *)jarg3;
39429   if (!argp3) {
39430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39431     return ;
39432   }
39433   arg3 = *argp3;
39434   {
39435     try {
39436       (arg1)->OnPropertySet(arg2,arg3);
39437     } catch (std::out_of_range& e) {
39438       {
39439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39440       };
39441     } catch (std::exception& e) {
39442       {
39443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39444       };
39445     } catch (Dali::DaliException e) {
39446       {
39447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39448       };
39449     } catch (...) {
39450       {
39451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39452       };
39453     }
39454   }
39455
39456 }
39457
39458
39459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39461   Dali::Vector3 *arg2 = 0 ;
39462
39463   arg1 = (Dali::CustomActorImpl *)jarg1;
39464   arg2 = (Dali::Vector3 *)jarg2;
39465   if (!arg2) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39467     return ;
39468   }
39469   {
39470     try {
39471       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39472     } catch (std::out_of_range& e) {
39473       {
39474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39475       };
39476     } catch (std::exception& e) {
39477       {
39478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39479       };
39480     } catch (Dali::DaliException e) {
39481       {
39482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39483       };
39484     } catch (...) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39487       };
39488     }
39489   }
39490
39491 }
39492
39493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39495   Dali::Animation *arg2 = 0 ;
39496   Dali::Vector3 *arg3 = 0 ;
39497
39498   arg1 = (Dali::CustomActorImpl *)jarg1;
39499   arg2 = (Dali::Animation *)jarg2;
39500   if (!arg2) {
39501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39502     return ;
39503   }
39504   arg3 = (Dali::Vector3 *)jarg3;
39505   if (!arg3) {
39506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39507     return ;
39508   }
39509   {
39510     try {
39511       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39512     } catch (std::out_of_range& e) {
39513       {
39514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (std::exception& e) {
39517       {
39518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39519       };
39520     } catch (Dali::DaliException e) {
39521       {
39522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39523       };
39524     } catch (...) {
39525       {
39526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39527       };
39528     }
39529   }
39530
39531 }
39532
39533
39534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39535   unsigned int jresult ;
39536   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39537   Dali::TouchEvent *arg2 = 0 ;
39538   bool result;
39539
39540   arg1 = (Dali::CustomActorImpl *)jarg1;
39541   arg2 = (Dali::TouchEvent *)jarg2;
39542   if (!arg2) {
39543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39544     return 0;
39545   }
39546   {
39547     try {
39548       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39549     } catch (std::out_of_range& e) {
39550       {
39551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39552       };
39553     } catch (std::exception& e) {
39554       {
39555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39556       };
39557     } catch (Dali::DaliException e) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39560       };
39561     } catch (...) {
39562       {
39563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39564       };
39565     }
39566   }
39567
39568   jresult = result;
39569   return jresult;
39570 }
39571
39572
39573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39574   unsigned int jresult ;
39575   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39576   Dali::HoverEvent *arg2 = 0 ;
39577   bool result;
39578
39579   arg1 = (Dali::CustomActorImpl *)jarg1;
39580   arg2 = (Dali::HoverEvent *)jarg2;
39581   if (!arg2) {
39582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39583     return 0;
39584   }
39585   {
39586     try {
39587       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39595       };
39596     } catch (Dali::DaliException e) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39599       };
39600     } catch (...) {
39601       {
39602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39603       };
39604     }
39605   }
39606
39607   jresult = result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39613   unsigned int jresult ;
39614   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39615   Dali::KeyEvent *arg2 = 0 ;
39616   bool result;
39617
39618   arg1 = (Dali::CustomActorImpl *)jarg1;
39619   arg2 = (Dali::KeyEvent *)jarg2;
39620   if (!arg2) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39622     return 0;
39623   }
39624   {
39625     try {
39626       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39627     } catch (std::out_of_range& e) {
39628       {
39629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39630       };
39631     } catch (std::exception& e) {
39632       {
39633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39634       };
39635     } catch (Dali::DaliException e) {
39636       {
39637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39638       };
39639     } catch (...) {
39640       {
39641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39642       };
39643     }
39644   }
39645
39646   jresult = result;
39647   return jresult;
39648 }
39649
39650
39651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39652   unsigned int jresult ;
39653   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39654   Dali::WheelEvent *arg2 = 0 ;
39655   bool result;
39656
39657   arg1 = (Dali::CustomActorImpl *)jarg1;
39658   arg2 = (Dali::WheelEvent *)jarg2;
39659   if (!arg2) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39661     return 0;
39662   }
39663   {
39664     try {
39665       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39666     } catch (std::out_of_range& e) {
39667       {
39668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39669       };
39670     } catch (std::exception& e) {
39671       {
39672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39673       };
39674     } catch (Dali::DaliException e) {
39675       {
39676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39677       };
39678     } catch (...) {
39679       {
39680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39681       };
39682     }
39683   }
39684
39685   jresult = result;
39686   return jresult;
39687 }
39688
39689
39690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39692   Dali::Vector2 *arg2 = 0 ;
39693   Dali::RelayoutContainer *arg3 = 0 ;
39694
39695   arg1 = (Dali::CustomActorImpl *)jarg1;
39696   arg2 = (Dali::Vector2 *)jarg2;
39697   if (!arg2) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39699     return ;
39700   }
39701   arg3 = (Dali::RelayoutContainer *)jarg3;
39702   if (!arg3) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39704     return ;
39705   }
39706   {
39707     try {
39708       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39709     } catch (std::out_of_range& e) {
39710       {
39711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39712       };
39713     } catch (std::exception& e) {
39714       {
39715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39716       };
39717     } catch (Dali::DaliException e) {
39718       {
39719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39720       };
39721     } catch (...) {
39722       {
39723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39724       };
39725     }
39726   }
39727
39728 }
39729
39730
39731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39732   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39733   Dali::ResizePolicy::Type arg2 ;
39734   Dali::Dimension::Type arg3 ;
39735
39736   arg1 = (Dali::CustomActorImpl *)jarg1;
39737   arg2 = (Dali::ResizePolicy::Type)jarg2;
39738   arg3 = (Dali::Dimension::Type)jarg3;
39739   {
39740     try {
39741       (arg1)->OnSetResizePolicy(arg2,arg3);
39742     } catch (std::out_of_range& e) {
39743       {
39744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39745       };
39746     } catch (std::exception& e) {
39747       {
39748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39749       };
39750     } catch (Dali::DaliException e) {
39751       {
39752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39753       };
39754     } catch (...) {
39755       {
39756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39757       };
39758     }
39759   }
39760
39761 }
39762
39763
39764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39765   void * jresult ;
39766   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39767   Dali::Vector3 result;
39768
39769   arg1 = (Dali::CustomActorImpl *)jarg1;
39770   {
39771     try {
39772       result = (arg1)->GetNaturalSize();
39773     } catch (std::out_of_range& e) {
39774       {
39775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39776       };
39777     } catch (std::exception& e) {
39778       {
39779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39780       };
39781     } catch (Dali::DaliException e) {
39782       {
39783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39784       };
39785     } catch (...) {
39786       {
39787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39788       };
39789     }
39790   }
39791
39792   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39793   return jresult;
39794 }
39795
39796
39797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39798   float jresult ;
39799   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39800   Dali::Actor *arg2 = 0 ;
39801   Dali::Dimension::Type arg3 ;
39802   float result;
39803
39804   arg1 = (Dali::CustomActorImpl *)jarg1;
39805   arg2 = (Dali::Actor *)jarg2;
39806   if (!arg2) {
39807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39808     return 0;
39809   }
39810   arg3 = (Dali::Dimension::Type)jarg3;
39811   {
39812     try {
39813       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39821       };
39822     } catch (Dali::DaliException e) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39825       };
39826     } catch (...) {
39827       {
39828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39829       };
39830     }
39831   }
39832
39833   jresult = result;
39834   return jresult;
39835 }
39836
39837
39838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39839   float jresult ;
39840   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39841   float arg2 ;
39842   float result;
39843
39844   arg1 = (Dali::CustomActorImpl *)jarg1;
39845   arg2 = (float)jarg2;
39846   {
39847     try {
39848       result = (float)(arg1)->GetHeightForWidth(arg2);
39849     } catch (std::out_of_range& e) {
39850       {
39851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39852       };
39853     } catch (std::exception& e) {
39854       {
39855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39856       };
39857     } catch (Dali::DaliException e) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39860       };
39861     } catch (...) {
39862       {
39863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39864       };
39865     }
39866   }
39867
39868   jresult = result;
39869   return jresult;
39870 }
39871
39872
39873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39874   float jresult ;
39875   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39876   float arg2 ;
39877   float result;
39878
39879   arg1 = (Dali::CustomActorImpl *)jarg1;
39880   arg2 = (float)jarg2;
39881   {
39882     try {
39883       result = (float)(arg1)->GetWidthForHeight(arg2);
39884     } catch (std::out_of_range& e) {
39885       {
39886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39887       };
39888     } catch (std::exception& e) {
39889       {
39890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39891       };
39892     } catch (Dali::DaliException e) {
39893       {
39894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39895       };
39896     } catch (...) {
39897       {
39898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39899       };
39900     }
39901   }
39902
39903   jresult = result;
39904   return jresult;
39905 }
39906
39907
39908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39909   unsigned int jresult ;
39910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39911   Dali::Dimension::Type arg2 ;
39912   bool result;
39913
39914   arg1 = (Dali::CustomActorImpl *)jarg1;
39915   arg2 = (Dali::Dimension::Type)jarg2;
39916   {
39917     try {
39918       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39919     } catch (std::out_of_range& e) {
39920       {
39921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39922       };
39923     } catch (std::exception& e) {
39924       {
39925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39926       };
39927     } catch (Dali::DaliException e) {
39928       {
39929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39930       };
39931     } catch (...) {
39932       {
39933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39934       };
39935     }
39936   }
39937
39938   jresult = result;
39939   return jresult;
39940 }
39941
39942
39943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39944   unsigned int jresult ;
39945   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39946   bool result;
39947
39948   arg1 = (Dali::CustomActorImpl *)jarg1;
39949   {
39950     try {
39951       result = (bool)(arg1)->RelayoutDependentOnChildren();
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39959       };
39960     } catch (Dali::DaliException e) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39963       };
39964     } catch (...) {
39965       {
39966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39967       };
39968     }
39969   }
39970
39971   jresult = result;
39972   return jresult;
39973 }
39974
39975
39976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39977   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39978   Dali::Dimension::Type arg2 ;
39979
39980   arg1 = (Dali::CustomActorImpl *)jarg1;
39981   arg2 = (Dali::Dimension::Type)jarg2;
39982   {
39983     try {
39984       (arg1)->OnCalculateRelayoutSize(arg2);
39985     } catch (std::out_of_range& e) {
39986       {
39987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39988       };
39989     } catch (std::exception& e) {
39990       {
39991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39992       };
39993     } catch (Dali::DaliException e) {
39994       {
39995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39996       };
39997     } catch (...) {
39998       {
39999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40000       };
40001     }
40002   }
40003
40004 }
40005
40006
40007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40008   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40009   float arg2 ;
40010   Dali::Dimension::Type arg3 ;
40011
40012   arg1 = (Dali::CustomActorImpl *)jarg1;
40013   arg2 = (float)jarg2;
40014   arg3 = (Dali::Dimension::Type)jarg3;
40015   {
40016     try {
40017       (arg1)->OnLayoutNegotiated(arg2,arg3);
40018     } catch (std::out_of_range& e) {
40019       {
40020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40021       };
40022     } catch (std::exception& e) {
40023       {
40024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40025       };
40026     } catch (Dali::DaliException e) {
40027       {
40028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40033       };
40034     }
40035   }
40036
40037 }
40038
40039
40040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40041   unsigned int jresult ;
40042   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40043   bool result;
40044
40045   arg1 = (Dali::CustomActorImpl *)jarg1;
40046   {
40047     try {
40048       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40049     } catch (std::out_of_range& e) {
40050       {
40051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40052       };
40053     } catch (std::exception& e) {
40054       {
40055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40056       };
40057     } catch (Dali::DaliException e) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40060       };
40061     } catch (...) {
40062       {
40063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40064       };
40065     }
40066   }
40067
40068   jresult = result;
40069   return jresult;
40070 }
40071
40072
40073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40074   unsigned int jresult ;
40075   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40076   bool result;
40077
40078   arg1 = (Dali::CustomActorImpl *)jarg1;
40079   {
40080     try {
40081       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40082     } catch (std::out_of_range& e) {
40083       {
40084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40085       };
40086     } catch (std::exception& e) {
40087       {
40088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40089       };
40090     } catch (Dali::DaliException e) {
40091       {
40092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40093       };
40094     } catch (...) {
40095       {
40096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40097       };
40098     }
40099   }
40100
40101   jresult = result;
40102   return jresult;
40103 }
40104
40105
40106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40107   unsigned int jresult ;
40108   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40109   bool result;
40110
40111   arg1 = (Dali::CustomActorImpl *)jarg1;
40112   {
40113     try {
40114       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40115     } catch (std::out_of_range& e) {
40116       {
40117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40118       };
40119     } catch (std::exception& e) {
40120       {
40121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40122       };
40123     } catch (Dali::DaliException e) {
40124       {
40125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40126       };
40127     } catch (...) {
40128       {
40129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40130       };
40131     }
40132   }
40133
40134   jresult = result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40140   unsigned int jresult ;
40141   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40142   bool result;
40143
40144   arg1 = (Dali::CustomActorImpl *)jarg1;
40145   {
40146     try {
40147       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40148     } catch (std::out_of_range& e) {
40149       {
40150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40151       };
40152     } catch (std::exception& e) {
40153       {
40154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40155       };
40156     } catch (Dali::DaliException e) {
40157       {
40158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40163       };
40164     }
40165   }
40166
40167   jresult = result;
40168   return jresult;
40169 }
40170
40171
40172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40173   void * jresult ;
40174   Dali::CustomActor *result = 0 ;
40175
40176   {
40177     try {
40178       result = (Dali::CustomActor *)new Dali::CustomActor();
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40186       };
40187     } catch (Dali::DaliException e) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40190       };
40191     } catch (...) {
40192       {
40193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40194       };
40195     }
40196   }
40197
40198   jresult = (void *)result;
40199   return jresult;
40200 }
40201
40202
40203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40204   void * jresult ;
40205   Dali::BaseHandle arg1 ;
40206   Dali::BaseHandle *argp1 ;
40207   Dali::CustomActor result;
40208
40209   argp1 = (Dali::BaseHandle *)jarg1;
40210   if (!argp1) {
40211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40212     return 0;
40213   }
40214   arg1 = *argp1;
40215   {
40216     try {
40217       result = Dali::CustomActor::DownCast(arg1);
40218     } catch (std::out_of_range& e) {
40219       {
40220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40221       };
40222     } catch (std::exception& e) {
40223       {
40224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40225       };
40226     } catch (Dali::DaliException e) {
40227       {
40228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40229       };
40230     } catch (...) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40233       };
40234     }
40235   }
40236
40237   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40238   return jresult;
40239 }
40240
40241
40242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40243   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40244
40245   arg1 = (Dali::CustomActor *)jarg1;
40246   {
40247     try {
40248       delete arg1;
40249     } catch (std::out_of_range& e) {
40250       {
40251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40252       };
40253     } catch (std::exception& e) {
40254       {
40255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40256       };
40257     } catch (Dali::DaliException e) {
40258       {
40259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40260       };
40261     } catch (...) {
40262       {
40263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40264       };
40265     }
40266   }
40267
40268 }
40269
40270
40271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40272   void * jresult ;
40273   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40274   Dali::CustomActorImpl *result = 0 ;
40275
40276   arg1 = (Dali::CustomActor *)jarg1;
40277   {
40278     try {
40279       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40280     } catch (std::out_of_range& e) {
40281       {
40282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40283       };
40284     } catch (std::exception& e) {
40285       {
40286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40287       };
40288     } catch (Dali::DaliException e) {
40289       {
40290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40291       };
40292     } catch (...) {
40293       {
40294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40295       };
40296     }
40297   }
40298
40299   jresult = (void *)result;
40300   return jresult;
40301 }
40302
40303
40304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40305   void * jresult ;
40306   Dali::CustomActorImpl *arg1 = 0 ;
40307   Dali::CustomActor *result = 0 ;
40308
40309   arg1 = (Dali::CustomActorImpl *)jarg1;
40310   if (!arg1) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40312     return 0;
40313   }
40314   {
40315     try {
40316       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40317     } catch (std::out_of_range& e) {
40318       {
40319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40320       };
40321     } catch (std::exception& e) {
40322       {
40323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40324       };
40325     } catch (Dali::DaliException e) {
40326       {
40327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40328       };
40329     } catch (...) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40332       };
40333     }
40334   }
40335
40336   jresult = (void *)result;
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40342   void * jresult ;
40343   Dali::CustomActor *arg1 = 0 ;
40344   Dali::CustomActor *result = 0 ;
40345
40346   arg1 = (Dali::CustomActor *)jarg1;
40347   if (!arg1) {
40348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40349     return 0;
40350   }
40351   {
40352     try {
40353       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40369       };
40370     }
40371   }
40372
40373   jresult = (void *)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40379   void * jresult ;
40380   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40381   Dali::CustomActor *arg2 = 0 ;
40382   Dali::CustomActor *result = 0 ;
40383
40384   arg1 = (Dali::CustomActor *)jarg1;
40385   arg2 = (Dali::CustomActor *)jarg2;
40386   if (!arg2) {
40387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40388     return 0;
40389   }
40390   {
40391     try {
40392       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (Dali::DaliException e) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40404       };
40405     } catch (...) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40408       };
40409     }
40410   }
40411
40412   jresult = (void *)result;
40413   return jresult;
40414 }
40415
40416
40417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40418   int jresult ;
40419   int result;
40420
40421   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40422   jresult = (int)result;
40423   return jresult;
40424 }
40425
40426
40427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40428   int jresult ;
40429   int result;
40430
40431   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40432   jresult = (int)result;
40433   return jresult;
40434 }
40435
40436
40437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40438   int jresult ;
40439   int result;
40440
40441   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40442   jresult = (int)result;
40443   return jresult;
40444 }
40445
40446
40447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40448   int jresult ;
40449   int result;
40450
40451   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40452   jresult = (int)result;
40453   return jresult;
40454 }
40455
40456
40457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40458   int jresult ;
40459   int result;
40460
40461   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40462   jresult = (int)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40468   int jresult ;
40469   int result;
40470
40471   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40472   jresult = (int)result;
40473   return jresult;
40474 }
40475
40476
40477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40478   int jresult ;
40479   int result;
40480
40481   result = (int)Dali::PanGestureDetector::Property::PANNING;
40482   jresult = (int)result;
40483   return jresult;
40484 }
40485
40486
40487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40488   void * jresult ;
40489   Dali::PanGestureDetector::Property *result = 0 ;
40490
40491   {
40492     try {
40493       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40494     } catch (std::out_of_range& e) {
40495       {
40496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40497       };
40498     } catch (std::exception& e) {
40499       {
40500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40501       };
40502     } catch (Dali::DaliException e) {
40503       {
40504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40505       };
40506     } catch (...) {
40507       {
40508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40509       };
40510     }
40511   }
40512
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40519   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40520
40521   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40522   {
40523     try {
40524       delete arg1;
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40540       };
40541     }
40542   }
40543
40544 }
40545
40546
40547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40548   void * jresult ;
40549   Dali::Radian *result = 0 ;
40550
40551   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40552   jresult = (void *)result;
40553   return jresult;
40554 }
40555
40556
40557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40558   void * jresult ;
40559   Dali::Radian *result = 0 ;
40560
40561   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40562   jresult = (void *)result;
40563   return jresult;
40564 }
40565
40566
40567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40568   void * jresult ;
40569   Dali::Radian *result = 0 ;
40570
40571   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40572   jresult = (void *)result;
40573   return jresult;
40574 }
40575
40576
40577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40578   void * jresult ;
40579   Dali::Radian *result = 0 ;
40580
40581   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40582   jresult = (void *)result;
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40588   void * jresult ;
40589   Dali::Radian *result = 0 ;
40590
40591   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40592   jresult = (void *)result;
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40598   void * jresult ;
40599   Dali::Radian *result = 0 ;
40600
40601   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40602   jresult = (void *)result;
40603   return jresult;
40604 }
40605
40606
40607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40608   void * jresult ;
40609   Dali::Radian *result = 0 ;
40610
40611   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40612   jresult = (void *)result;
40613   return jresult;
40614 }
40615
40616
40617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40618   void * jresult ;
40619   Dali::PanGestureDetector *result = 0 ;
40620
40621   {
40622     try {
40623       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40624     } catch (std::out_of_range& e) {
40625       {
40626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40627       };
40628     } catch (std::exception& e) {
40629       {
40630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40631       };
40632     } catch (Dali::DaliException e) {
40633       {
40634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40635       };
40636     } catch (...) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40639       };
40640     }
40641   }
40642
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40649   void * jresult ;
40650   Dali::PanGestureDetector result;
40651
40652   {
40653     try {
40654       result = Dali::PanGestureDetector::New();
40655     } catch (std::out_of_range& e) {
40656       {
40657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40658       };
40659     } catch (std::exception& e) {
40660       {
40661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40662       };
40663     } catch (Dali::DaliException e) {
40664       {
40665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40666       };
40667     } catch (...) {
40668       {
40669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40670       };
40671     }
40672   }
40673
40674   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40675   return jresult;
40676 }
40677
40678
40679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40680   void * jresult ;
40681   Dali::BaseHandle arg1 ;
40682   Dali::BaseHandle *argp1 ;
40683   Dali::PanGestureDetector result;
40684
40685   argp1 = (Dali::BaseHandle *)jarg1;
40686   if (!argp1) {
40687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40688     return 0;
40689   }
40690   arg1 = *argp1;
40691   {
40692     try {
40693       result = Dali::PanGestureDetector::DownCast(arg1);
40694     } catch (std::out_of_range& e) {
40695       {
40696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40697       };
40698     } catch (std::exception& e) {
40699       {
40700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40701       };
40702     } catch (Dali::DaliException e) {
40703       {
40704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40705       };
40706     } catch (...) {
40707       {
40708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40709       };
40710     }
40711   }
40712
40713   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40714   return jresult;
40715 }
40716
40717
40718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40719   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40720
40721   arg1 = (Dali::PanGestureDetector *)jarg1;
40722   {
40723     try {
40724       delete arg1;
40725     } catch (std::out_of_range& e) {
40726       {
40727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40728       };
40729     } catch (std::exception& e) {
40730       {
40731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40732       };
40733     } catch (Dali::DaliException e) {
40734       {
40735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40740       };
40741     }
40742   }
40743
40744 }
40745
40746
40747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40748   void * jresult ;
40749   Dali::PanGestureDetector *arg1 = 0 ;
40750   Dali::PanGestureDetector *result = 0 ;
40751
40752   arg1 = (Dali::PanGestureDetector *)jarg1;
40753   if (!arg1) {
40754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40755     return 0;
40756   }
40757   {
40758     try {
40759       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40760     } catch (std::out_of_range& e) {
40761       {
40762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40763       };
40764     } catch (std::exception& e) {
40765       {
40766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40767       };
40768     } catch (Dali::DaliException e) {
40769       {
40770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40771       };
40772     } catch (...) {
40773       {
40774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40775       };
40776     }
40777   }
40778
40779   jresult = (void *)result;
40780   return jresult;
40781 }
40782
40783
40784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40785   void * jresult ;
40786   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40787   Dali::PanGestureDetector *arg2 = 0 ;
40788   Dali::PanGestureDetector *result = 0 ;
40789
40790   arg1 = (Dali::PanGestureDetector *)jarg1;
40791   arg2 = (Dali::PanGestureDetector *)jarg2;
40792   if (!arg2) {
40793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40794     return 0;
40795   }
40796   {
40797     try {
40798       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40799     } catch (std::out_of_range& e) {
40800       {
40801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (std::exception& e) {
40804       {
40805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40806       };
40807     } catch (Dali::DaliException e) {
40808       {
40809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40810       };
40811     } catch (...) {
40812       {
40813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40814       };
40815     }
40816   }
40817
40818   jresult = (void *)result;
40819   return jresult;
40820 }
40821
40822
40823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40825   unsigned int arg2 ;
40826
40827   arg1 = (Dali::PanGestureDetector *)jarg1;
40828   arg2 = (unsigned int)jarg2;
40829   {
40830     try {
40831       (arg1)->SetMinimumTouchesRequired(arg2);
40832     } catch (std::out_of_range& e) {
40833       {
40834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40835       };
40836     } catch (std::exception& e) {
40837       {
40838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40839       };
40840     } catch (Dali::DaliException e) {
40841       {
40842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40843       };
40844     } catch (...) {
40845       {
40846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40847       };
40848     }
40849   }
40850
40851 }
40852
40853
40854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40855   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40856   unsigned int arg2 ;
40857
40858   arg1 = (Dali::PanGestureDetector *)jarg1;
40859   arg2 = (unsigned int)jarg2;
40860   {
40861     try {
40862       (arg1)->SetMaximumTouchesRequired(arg2);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (Dali::DaliException e) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40874       };
40875     } catch (...) {
40876       {
40877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40878       };
40879     }
40880   }
40881
40882 }
40883
40884
40885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40886   unsigned int jresult ;
40887   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40888   unsigned int result;
40889
40890   arg1 = (Dali::PanGestureDetector *)jarg1;
40891   {
40892     try {
40893       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40894     } catch (std::out_of_range& e) {
40895       {
40896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40897       };
40898     } catch (std::exception& e) {
40899       {
40900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40901       };
40902     } catch (Dali::DaliException e) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40905       };
40906     } catch (...) {
40907       {
40908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40909       };
40910     }
40911   }
40912
40913   jresult = result;
40914   return jresult;
40915 }
40916
40917
40918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40919   unsigned int jresult ;
40920   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40921   unsigned int result;
40922
40923   arg1 = (Dali::PanGestureDetector *)jarg1;
40924   {
40925     try {
40926       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40927     } catch (std::out_of_range& e) {
40928       {
40929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40930       };
40931     } catch (std::exception& e) {
40932       {
40933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40934       };
40935     } catch (Dali::DaliException e) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40938       };
40939     } catch (...) {
40940       {
40941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40942       };
40943     }
40944   }
40945
40946   jresult = result;
40947   return jresult;
40948 }
40949
40950
40951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40953   Dali::Radian arg2 ;
40954   Dali::Radian arg3 ;
40955   Dali::Radian *argp2 ;
40956   Dali::Radian *argp3 ;
40957
40958   arg1 = (Dali::PanGestureDetector *)jarg1;
40959   argp2 = (Dali::Radian *)jarg2;
40960   if (!argp2) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg2 = *argp2;
40965   argp3 = (Dali::Radian *)jarg3;
40966   if (!argp3) {
40967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40968     return ;
40969   }
40970   arg3 = *argp3;
40971   {
40972     try {
40973       (arg1)->AddAngle(arg2,arg3);
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40981       };
40982     } catch (Dali::DaliException e) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40989       };
40990     }
40991   }
40992
40993 }
40994
40995
40996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40997   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40998   Dali::Radian arg2 ;
40999   Dali::Radian *argp2 ;
41000
41001   arg1 = (Dali::PanGestureDetector *)jarg1;
41002   argp2 = (Dali::Radian *)jarg2;
41003   if (!argp2) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41005     return ;
41006   }
41007   arg2 = *argp2;
41008   {
41009     try {
41010       (arg1)->AddAngle(arg2);
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41026       };
41027     }
41028   }
41029
41030 }
41031
41032
41033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41034   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41035   Dali::Radian arg2 ;
41036   Dali::Radian arg3 ;
41037   Dali::Radian *argp2 ;
41038   Dali::Radian *argp3 ;
41039
41040   arg1 = (Dali::PanGestureDetector *)jarg1;
41041   argp2 = (Dali::Radian *)jarg2;
41042   if (!argp2) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41044     return ;
41045   }
41046   arg2 = *argp2;
41047   argp3 = (Dali::Radian *)jarg3;
41048   if (!argp3) {
41049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41050     return ;
41051   }
41052   arg3 = *argp3;
41053   {
41054     try {
41055       (arg1)->AddDirection(arg2,arg3);
41056     } catch (std::out_of_range& e) {
41057       {
41058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41059       };
41060     } catch (std::exception& e) {
41061       {
41062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41063       };
41064     } catch (Dali::DaliException e) {
41065       {
41066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41067       };
41068     } catch (...) {
41069       {
41070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41071       };
41072     }
41073   }
41074
41075 }
41076
41077
41078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41079   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41080   Dali::Radian arg2 ;
41081   Dali::Radian *argp2 ;
41082
41083   arg1 = (Dali::PanGestureDetector *)jarg1;
41084   argp2 = (Dali::Radian *)jarg2;
41085   if (!argp2) {
41086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41087     return ;
41088   }
41089   arg2 = *argp2;
41090   {
41091     try {
41092       (arg1)->AddDirection(arg2);
41093     } catch (std::out_of_range& e) {
41094       {
41095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41096       };
41097     } catch (std::exception& e) {
41098       {
41099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41100       };
41101     } catch (Dali::DaliException e) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41108       };
41109     }
41110   }
41111
41112 }
41113
41114
41115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41116   unsigned long jresult ;
41117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41118   size_t result;
41119
41120   arg1 = (Dali::PanGestureDetector *)jarg1;
41121   {
41122     try {
41123       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41124     } catch (std::out_of_range& e) {
41125       {
41126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41127       };
41128     } catch (std::exception& e) {
41129       {
41130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41131       };
41132     } catch (Dali::DaliException e) {
41133       {
41134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41135       };
41136     } catch (...) {
41137       {
41138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41139       };
41140     }
41141   }
41142
41143   jresult = (unsigned long)result;
41144   return jresult;
41145 }
41146
41147
41148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41149   void * jresult ;
41150   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41151   size_t arg2 ;
41152   Dali::PanGestureDetector::AngleThresholdPair result;
41153
41154   arg1 = (Dali::PanGestureDetector *)jarg1;
41155   arg2 = (size_t)jarg2;
41156   {
41157     try {
41158       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41159     } catch (std::out_of_range& e) {
41160       {
41161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (std::exception& e) {
41164       {
41165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41166       };
41167     } catch (Dali::DaliException e) {
41168       {
41169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41170       };
41171     } catch (...) {
41172       {
41173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41174       };
41175     }
41176   }
41177
41178   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41179   return jresult;
41180 }
41181
41182
41183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41184   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41185
41186   arg1 = (Dali::PanGestureDetector *)jarg1;
41187   {
41188     try {
41189       (arg1)->ClearAngles();
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41197       };
41198     } catch (Dali::DaliException e) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41205       };
41206     }
41207   }
41208
41209 }
41210
41211
41212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41213   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41214   Dali::Radian arg2 ;
41215   Dali::Radian *argp2 ;
41216
41217   arg1 = (Dali::PanGestureDetector *)jarg1;
41218   argp2 = (Dali::Radian *)jarg2;
41219   if (!argp2) {
41220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41221     return ;
41222   }
41223   arg2 = *argp2;
41224   {
41225     try {
41226       (arg1)->RemoveAngle(arg2);
41227     } catch (std::out_of_range& e) {
41228       {
41229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41230       };
41231     } catch (std::exception& e) {
41232       {
41233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41234       };
41235     } catch (Dali::DaliException e) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41242       };
41243     }
41244   }
41245
41246 }
41247
41248
41249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41250   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41251   Dali::Radian arg2 ;
41252   Dali::Radian *argp2 ;
41253
41254   arg1 = (Dali::PanGestureDetector *)jarg1;
41255   argp2 = (Dali::Radian *)jarg2;
41256   if (!argp2) {
41257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41258     return ;
41259   }
41260   arg2 = *argp2;
41261   {
41262     try {
41263       (arg1)->RemoveDirection(arg2);
41264     } catch (std::out_of_range& e) {
41265       {
41266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41267       };
41268     } catch (std::exception& e) {
41269       {
41270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41271       };
41272     } catch (Dali::DaliException e) {
41273       {
41274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41275       };
41276     } catch (...) {
41277       {
41278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41279       };
41280     }
41281   }
41282
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41287   void * jresult ;
41288   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41289   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41290
41291   arg1 = (Dali::PanGestureDetector *)jarg1;
41292   {
41293     try {
41294       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41295     } catch (std::out_of_range& e) {
41296       {
41297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41298       };
41299     } catch (std::exception& e) {
41300       {
41301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (Dali::DaliException e) {
41304       {
41305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41306       };
41307     } catch (...) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41310       };
41311     }
41312   }
41313
41314   jresult = (void *)result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41320   Dali::PanGesture *arg1 = 0 ;
41321
41322   arg1 = (Dali::PanGesture *)jarg1;
41323   if (!arg1) {
41324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41325     return ;
41326   }
41327   {
41328     try {
41329       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41330     } catch (std::out_of_range& e) {
41331       {
41332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41333       };
41334     } catch (std::exception& e) {
41335       {
41336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41337       };
41338     } catch (Dali::DaliException e) {
41339       {
41340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41341       };
41342     } catch (...) {
41343       {
41344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41345       };
41346     }
41347   }
41348
41349 }
41350
41351
41352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41353   void * jresult ;
41354   Dali::PanGesture *result = 0 ;
41355
41356   {
41357     try {
41358       result = (Dali::PanGesture *)new Dali::PanGesture();
41359     } catch (std::out_of_range& e) {
41360       {
41361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41362       };
41363     } catch (std::exception& e) {
41364       {
41365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41366       };
41367     } catch (Dali::DaliException e) {
41368       {
41369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41370       };
41371     } catch (...) {
41372       {
41373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41374       };
41375     }
41376   }
41377
41378   jresult = (void *)result;
41379   return jresult;
41380 }
41381
41382
41383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41384   void * jresult ;
41385   Dali::Gesture::State arg1 ;
41386   Dali::PanGesture *result = 0 ;
41387
41388   arg1 = (Dali::Gesture::State)jarg1;
41389   {
41390     try {
41391       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41392     } catch (std::out_of_range& e) {
41393       {
41394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41395       };
41396     } catch (std::exception& e) {
41397       {
41398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41399       };
41400     } catch (Dali::DaliException e) {
41401       {
41402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41403       };
41404     } catch (...) {
41405       {
41406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41407       };
41408     }
41409   }
41410
41411   jresult = (void *)result;
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41417   void * jresult ;
41418   Dali::PanGesture *arg1 = 0 ;
41419   Dali::PanGesture *result = 0 ;
41420
41421   arg1 = (Dali::PanGesture *)jarg1;
41422   if (!arg1) {
41423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41424     return 0;
41425   }
41426   {
41427     try {
41428       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41429     } catch (std::out_of_range& e) {
41430       {
41431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (std::exception& e) {
41434       {
41435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (Dali::DaliException e) {
41438       {
41439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447
41448   jresult = (void *)result;
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41454   void * jresult ;
41455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41456   Dali::PanGesture *arg2 = 0 ;
41457   Dali::PanGesture *result = 0 ;
41458
41459   arg1 = (Dali::PanGesture *)jarg1;
41460   arg2 = (Dali::PanGesture *)jarg2;
41461   if (!arg2) {
41462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41463     return 0;
41464   }
41465   {
41466     try {
41467       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41475       };
41476     } catch (Dali::DaliException e) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41479       };
41480     } catch (...) {
41481       {
41482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41483       };
41484     }
41485   }
41486
41487   jresult = (void *)result;
41488   return jresult;
41489 }
41490
41491
41492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41493   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41494
41495   arg1 = (Dali::PanGesture *)jarg1;
41496   {
41497     try {
41498       delete arg1;
41499     } catch (std::out_of_range& e) {
41500       {
41501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41502       };
41503     } catch (std::exception& e) {
41504       {
41505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41506       };
41507     } catch (Dali::DaliException e) {
41508       {
41509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41510       };
41511     } catch (...) {
41512       {
41513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41514       };
41515     }
41516   }
41517
41518 }
41519
41520
41521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   arg2 = (Dali::Vector2 *)jarg2;
41527   if (arg1) (arg1)->velocity = *arg2;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41532   void * jresult ;
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   Dali::Vector2 *result = 0 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   result = (Dali::Vector2 *)& ((arg1)->velocity);
41538   jresult = (void *)result;
41539   return jresult;
41540 }
41541
41542
41543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   arg2 = (Dali::Vector2 *)jarg2;
41549   if (arg1) (arg1)->displacement = *arg2;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41554   void * jresult ;
41555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41556   Dali::Vector2 *result = 0 ;
41557
41558   arg1 = (Dali::PanGesture *)jarg1;
41559   result = (Dali::Vector2 *)& ((arg1)->displacement);
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41568
41569   arg1 = (Dali::PanGesture *)jarg1;
41570   arg2 = (Dali::Vector2 *)jarg2;
41571   if (arg1) (arg1)->position = *arg2;
41572 }
41573
41574
41575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41576   void * jresult ;
41577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41578   Dali::Vector2 *result = 0 ;
41579
41580   arg1 = (Dali::PanGesture *)jarg1;
41581   result = (Dali::Vector2 *)& ((arg1)->position);
41582   jresult = (void *)result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   arg2 = (Dali::Vector2 *)jarg2;
41593   if (arg1) (arg1)->screenVelocity = *arg2;
41594 }
41595
41596
41597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41598   void * jresult ;
41599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41600   Dali::Vector2 *result = 0 ;
41601
41602   arg1 = (Dali::PanGesture *)jarg1;
41603   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41604   jresult = (void *)result;
41605   return jresult;
41606 }
41607
41608
41609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41610   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41611   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41612
41613   arg1 = (Dali::PanGesture *)jarg1;
41614   arg2 = (Dali::Vector2 *)jarg2;
41615   if (arg1) (arg1)->screenDisplacement = *arg2;
41616 }
41617
41618
41619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41620   void * jresult ;
41621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41622   Dali::Vector2 *result = 0 ;
41623
41624   arg1 = (Dali::PanGesture *)jarg1;
41625   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41626   jresult = (void *)result;
41627   return jresult;
41628 }
41629
41630
41631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41632   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41633   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41634
41635   arg1 = (Dali::PanGesture *)jarg1;
41636   arg2 = (Dali::Vector2 *)jarg2;
41637   if (arg1) (arg1)->screenPosition = *arg2;
41638 }
41639
41640
41641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41642   void * jresult ;
41643   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41644   Dali::Vector2 *result = 0 ;
41645
41646   arg1 = (Dali::PanGesture *)jarg1;
41647   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41648   jresult = (void *)result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41654   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41655   unsigned int arg2 ;
41656
41657   arg1 = (Dali::PanGesture *)jarg1;
41658   arg2 = (unsigned int)jarg2;
41659   if (arg1) (arg1)->numberOfTouches = arg2;
41660 }
41661
41662
41663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41664   unsigned int jresult ;
41665   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41666   unsigned int result;
41667
41668   arg1 = (Dali::PanGesture *)jarg1;
41669   result = (unsigned int) ((arg1)->numberOfTouches);
41670   jresult = result;
41671   return jresult;
41672 }
41673
41674
41675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41676   float jresult ;
41677   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41678   float result;
41679
41680   arg1 = (Dali::PanGesture *)jarg1;
41681   {
41682     try {
41683       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41684     } catch (std::out_of_range& e) {
41685       {
41686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (std::exception& e) {
41689       {
41690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41691       };
41692     } catch (Dali::DaliException e) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41695       };
41696     } catch (...) {
41697       {
41698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41699       };
41700     }
41701   }
41702
41703   jresult = result;
41704   return jresult;
41705 }
41706
41707
41708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41709   float jresult ;
41710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41711   float result;
41712
41713   arg1 = (Dali::PanGesture *)jarg1;
41714   {
41715     try {
41716       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735
41736   jresult = result;
41737   return jresult;
41738 }
41739
41740
41741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41742   float jresult ;
41743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41744   float result;
41745
41746   arg1 = (Dali::PanGesture *)jarg1;
41747   {
41748     try {
41749       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41750     } catch (std::out_of_range& e) {
41751       {
41752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41753       };
41754     } catch (std::exception& e) {
41755       {
41756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (Dali::DaliException e) {
41759       {
41760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768
41769   jresult = result;
41770   return jresult;
41771 }
41772
41773
41774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41775   float jresult ;
41776   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41777   float result;
41778
41779   arg1 = (Dali::PanGesture *)jarg1;
41780   {
41781     try {
41782       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (Dali::DaliException e) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41794       };
41795     } catch (...) {
41796       {
41797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41798       };
41799     }
41800   }
41801
41802   jresult = result;
41803   return jresult;
41804 }
41805
41806
41807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41808   void * jresult ;
41809   Dali::PinchGestureDetector *result = 0 ;
41810
41811   {
41812     try {
41813       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41829       };
41830     }
41831   }
41832
41833   jresult = (void *)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41839   void * jresult ;
41840   Dali::PinchGestureDetector result;
41841
41842   {
41843     try {
41844       result = Dali::PinchGestureDetector::New();
41845     } catch (std::out_of_range& e) {
41846       {
41847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (std::exception& e) {
41850       {
41851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (Dali::DaliException e) {
41854       {
41855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41856       };
41857     } catch (...) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41860       };
41861     }
41862   }
41863
41864   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41865   return jresult;
41866 }
41867
41868
41869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41870   void * jresult ;
41871   Dali::BaseHandle arg1 ;
41872   Dali::BaseHandle *argp1 ;
41873   Dali::PinchGestureDetector result;
41874
41875   argp1 = (Dali::BaseHandle *)jarg1;
41876   if (!argp1) {
41877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41878     return 0;
41879   }
41880   arg1 = *argp1;
41881   {
41882     try {
41883       result = Dali::PinchGestureDetector::DownCast(arg1);
41884     } catch (std::out_of_range& e) {
41885       {
41886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (std::exception& e) {
41889       {
41890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41891       };
41892     } catch (Dali::DaliException e) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41895       };
41896     } catch (...) {
41897       {
41898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41899       };
41900     }
41901   }
41902
41903   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41904   return jresult;
41905 }
41906
41907
41908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41909   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41910
41911   arg1 = (Dali::PinchGestureDetector *)jarg1;
41912   {
41913     try {
41914       delete arg1;
41915     } catch (std::out_of_range& e) {
41916       {
41917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41918       };
41919     } catch (std::exception& e) {
41920       {
41921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41922       };
41923     } catch (Dali::DaliException e) {
41924       {
41925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41926       };
41927     } catch (...) {
41928       {
41929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41930       };
41931     }
41932   }
41933
41934 }
41935
41936
41937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41938   void * jresult ;
41939   Dali::PinchGestureDetector *arg1 = 0 ;
41940   Dali::PinchGestureDetector *result = 0 ;
41941
41942   arg1 = (Dali::PinchGestureDetector *)jarg1;
41943   if (!arg1) {
41944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41945     return 0;
41946   }
41947   {
41948     try {
41949       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41950     } catch (std::out_of_range& e) {
41951       {
41952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41953       };
41954     } catch (std::exception& e) {
41955       {
41956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41957       };
41958     } catch (Dali::DaliException e) {
41959       {
41960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41961       };
41962     } catch (...) {
41963       {
41964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41965       };
41966     }
41967   }
41968
41969   jresult = (void *)result;
41970   return jresult;
41971 }
41972
41973
41974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41975   void * jresult ;
41976   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41977   Dali::PinchGestureDetector *arg2 = 0 ;
41978   Dali::PinchGestureDetector *result = 0 ;
41979
41980   arg1 = (Dali::PinchGestureDetector *)jarg1;
41981   arg2 = (Dali::PinchGestureDetector *)jarg2;
41982   if (!arg2) {
41983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41984     return 0;
41985   }
41986   {
41987     try {
41988       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41989     } catch (std::out_of_range& e) {
41990       {
41991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (std::exception& e) {
41994       {
41995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41996       };
41997     } catch (Dali::DaliException e) {
41998       {
41999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42000       };
42001     } catch (...) {
42002       {
42003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42004       };
42005     }
42006   }
42007
42008   jresult = (void *)result;
42009   return jresult;
42010 }
42011
42012
42013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42014   void * jresult ;
42015   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42016   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42017
42018   arg1 = (Dali::PinchGestureDetector *)jarg1;
42019   {
42020     try {
42021       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42022     } catch (std::out_of_range& e) {
42023       {
42024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42025       };
42026     } catch (std::exception& e) {
42027       {
42028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42029       };
42030     } catch (Dali::DaliException e) {
42031       {
42032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42033       };
42034     } catch (...) {
42035       {
42036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42037       };
42038     }
42039   }
42040
42041   jresult = (void *)result;
42042   return jresult;
42043 }
42044
42045
42046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42047   void * jresult ;
42048   Dali::Gesture::State arg1 ;
42049   Dali::PinchGesture *result = 0 ;
42050
42051   arg1 = (Dali::Gesture::State)jarg1;
42052   {
42053     try {
42054       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42055     } catch (std::out_of_range& e) {
42056       {
42057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42058       };
42059     } catch (std::exception& e) {
42060       {
42061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42062       };
42063     } catch (Dali::DaliException e) {
42064       {
42065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42066       };
42067     } catch (...) {
42068       {
42069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42070       };
42071     }
42072   }
42073
42074   jresult = (void *)result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42080   void * jresult ;
42081   Dali::PinchGesture *arg1 = 0 ;
42082   Dali::PinchGesture *result = 0 ;
42083
42084   arg1 = (Dali::PinchGesture *)jarg1;
42085   if (!arg1) {
42086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42087     return 0;
42088   }
42089   {
42090     try {
42091       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42092     } catch (std::out_of_range& e) {
42093       {
42094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42095       };
42096     } catch (std::exception& e) {
42097       {
42098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (Dali::DaliException e) {
42101       {
42102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42103       };
42104     } catch (...) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42107       };
42108     }
42109   }
42110
42111   jresult = (void *)result;
42112   return jresult;
42113 }
42114
42115
42116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42117   void * jresult ;
42118   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42119   Dali::PinchGesture *arg2 = 0 ;
42120   Dali::PinchGesture *result = 0 ;
42121
42122   arg1 = (Dali::PinchGesture *)jarg1;
42123   arg2 = (Dali::PinchGesture *)jarg2;
42124   if (!arg2) {
42125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42126     return 0;
42127   }
42128   {
42129     try {
42130       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42131     } catch (std::out_of_range& e) {
42132       {
42133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42134       };
42135     } catch (std::exception& e) {
42136       {
42137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (Dali::DaliException e) {
42140       {
42141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42142       };
42143     } catch (...) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42146       };
42147     }
42148   }
42149
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42156   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42157
42158   arg1 = (Dali::PinchGesture *)jarg1;
42159   {
42160     try {
42161       delete arg1;
42162     } catch (std::out_of_range& e) {
42163       {
42164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (std::exception& e) {
42167       {
42168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (Dali::DaliException e) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42173       };
42174     } catch (...) {
42175       {
42176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42177       };
42178     }
42179   }
42180
42181 }
42182
42183
42184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42185   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42186   float arg2 ;
42187
42188   arg1 = (Dali::PinchGesture *)jarg1;
42189   arg2 = (float)jarg2;
42190   if (arg1) (arg1)->scale = arg2;
42191 }
42192
42193
42194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42195   float jresult ;
42196   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42197   float result;
42198
42199   arg1 = (Dali::PinchGesture *)jarg1;
42200   result = (float) ((arg1)->scale);
42201   jresult = result;
42202   return jresult;
42203 }
42204
42205
42206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42207   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42208   float arg2 ;
42209
42210   arg1 = (Dali::PinchGesture *)jarg1;
42211   arg2 = (float)jarg2;
42212   if (arg1) (arg1)->speed = arg2;
42213 }
42214
42215
42216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42217   float jresult ;
42218   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42219   float result;
42220
42221   arg1 = (Dali::PinchGesture *)jarg1;
42222   result = (float) ((arg1)->speed);
42223   jresult = result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42230   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42231
42232   arg1 = (Dali::PinchGesture *)jarg1;
42233   arg2 = (Dali::Vector2 *)jarg2;
42234   if (arg1) (arg1)->screenCenterPoint = *arg2;
42235 }
42236
42237
42238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42239   void * jresult ;
42240   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42241   Dali::Vector2 *result = 0 ;
42242
42243   arg1 = (Dali::PinchGesture *)jarg1;
42244   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42245   jresult = (void *)result;
42246   return jresult;
42247 }
42248
42249
42250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42251   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42252   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42253
42254   arg1 = (Dali::PinchGesture *)jarg1;
42255   arg2 = (Dali::Vector2 *)jarg2;
42256   if (arg1) (arg1)->localCenterPoint = *arg2;
42257 }
42258
42259
42260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42261   void * jresult ;
42262   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42263   Dali::Vector2 *result = 0 ;
42264
42265   arg1 = (Dali::PinchGesture *)jarg1;
42266   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42267   jresult = (void *)result;
42268   return jresult;
42269 }
42270
42271
42272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42273   void * jresult ;
42274   Dali::TapGestureDetector *result = 0 ;
42275
42276   {
42277     try {
42278       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42279     } catch (std::out_of_range& e) {
42280       {
42281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (std::exception& e) {
42284       {
42285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42286       };
42287     } catch (Dali::DaliException e) {
42288       {
42289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42290       };
42291     } catch (...) {
42292       {
42293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42294       };
42295     }
42296   }
42297
42298   jresult = (void *)result;
42299   return jresult;
42300 }
42301
42302
42303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42304   void * jresult ;
42305   Dali::TapGestureDetector result;
42306
42307   {
42308     try {
42309       result = Dali::TapGestureDetector::New();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (Dali::DaliException e) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328
42329   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42335   void * jresult ;
42336   unsigned int arg1 ;
42337   Dali::TapGestureDetector result;
42338
42339   arg1 = (unsigned int)jarg1;
42340   {
42341     try {
42342       result = Dali::TapGestureDetector::New(arg1);
42343     } catch (std::out_of_range& e) {
42344       {
42345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (std::exception& e) {
42348       {
42349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42350       };
42351     } catch (Dali::DaliException e) {
42352       {
42353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42354       };
42355     } catch (...) {
42356       {
42357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42358       };
42359     }
42360   }
42361
42362   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42363   return jresult;
42364 }
42365
42366
42367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42368   void * jresult ;
42369   Dali::BaseHandle arg1 ;
42370   Dali::BaseHandle *argp1 ;
42371   Dali::TapGestureDetector result;
42372
42373   argp1 = (Dali::BaseHandle *)jarg1;
42374   if (!argp1) {
42375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42376     return 0;
42377   }
42378   arg1 = *argp1;
42379   {
42380     try {
42381       result = Dali::TapGestureDetector::DownCast(arg1);
42382     } catch (std::out_of_range& e) {
42383       {
42384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (std::exception& e) {
42387       {
42388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42389       };
42390     } catch (Dali::DaliException e) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42393       };
42394     } catch (...) {
42395       {
42396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42397       };
42398     }
42399   }
42400
42401   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42402   return jresult;
42403 }
42404
42405
42406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42407   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42408
42409   arg1 = (Dali::TapGestureDetector *)jarg1;
42410   {
42411     try {
42412       delete arg1;
42413     } catch (std::out_of_range& e) {
42414       {
42415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42416       };
42417     } catch (std::exception& e) {
42418       {
42419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42420       };
42421     } catch (Dali::DaliException e) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42424       };
42425     } catch (...) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42428       };
42429     }
42430   }
42431
42432 }
42433
42434
42435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42436   void * jresult ;
42437   Dali::TapGestureDetector *arg1 = 0 ;
42438   Dali::TapGestureDetector *result = 0 ;
42439
42440   arg1 = (Dali::TapGestureDetector *)jarg1;
42441   if (!arg1) {
42442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42443     return 0;
42444   }
42445   {
42446     try {
42447       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42448     } catch (std::out_of_range& e) {
42449       {
42450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42451       };
42452     } catch (std::exception& e) {
42453       {
42454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42455       };
42456     } catch (Dali::DaliException e) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42463       };
42464     }
42465   }
42466
42467   jresult = (void *)result;
42468   return jresult;
42469 }
42470
42471
42472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42473   void * jresult ;
42474   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42475   Dali::TapGestureDetector *arg2 = 0 ;
42476   Dali::TapGestureDetector *result = 0 ;
42477
42478   arg1 = (Dali::TapGestureDetector *)jarg1;
42479   arg2 = (Dali::TapGestureDetector *)jarg2;
42480   if (!arg2) {
42481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42482     return 0;
42483   }
42484   {
42485     try {
42486       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42487     } catch (std::out_of_range& e) {
42488       {
42489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42490       };
42491     } catch (std::exception& e) {
42492       {
42493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42494       };
42495     } catch (Dali::DaliException e) {
42496       {
42497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42498       };
42499     } catch (...) {
42500       {
42501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42502       };
42503     }
42504   }
42505
42506   jresult = (void *)result;
42507   return jresult;
42508 }
42509
42510
42511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42512   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42513   unsigned int arg2 ;
42514
42515   arg1 = (Dali::TapGestureDetector *)jarg1;
42516   arg2 = (unsigned int)jarg2;
42517   {
42518     try {
42519       (arg1)->SetMinimumTapsRequired(arg2);
42520     } catch (std::out_of_range& e) {
42521       {
42522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42523       };
42524     } catch (std::exception& e) {
42525       {
42526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42527       };
42528     } catch (Dali::DaliException e) {
42529       {
42530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42531       };
42532     } catch (...) {
42533       {
42534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42535       };
42536     }
42537   }
42538
42539 }
42540
42541
42542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42543   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42544   unsigned int arg2 ;
42545
42546   arg1 = (Dali::TapGestureDetector *)jarg1;
42547   arg2 = (unsigned int)jarg2;
42548   {
42549     try {
42550       (arg1)->SetMaximumTapsRequired(arg2);
42551     } catch (std::out_of_range& e) {
42552       {
42553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42554       };
42555     } catch (std::exception& e) {
42556       {
42557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42558       };
42559     } catch (Dali::DaliException e) {
42560       {
42561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42562       };
42563     } catch (...) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42566       };
42567     }
42568   }
42569
42570 }
42571
42572
42573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42574   unsigned int jresult ;
42575   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42576   unsigned int result;
42577
42578   arg1 = (Dali::TapGestureDetector *)jarg1;
42579   {
42580     try {
42581       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42582     } catch (std::out_of_range& e) {
42583       {
42584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (std::exception& e) {
42587       {
42588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (Dali::DaliException e) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600
42601   jresult = result;
42602   return jresult;
42603 }
42604
42605
42606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42607   unsigned int jresult ;
42608   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42609   unsigned int result;
42610
42611   arg1 = (Dali::TapGestureDetector *)jarg1;
42612   {
42613     try {
42614       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (Dali::DaliException e) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42626       };
42627     } catch (...) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42630       };
42631     }
42632   }
42633
42634   jresult = result;
42635   return jresult;
42636 }
42637
42638
42639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42640   void * jresult ;
42641   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42642   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42643
42644   arg1 = (Dali::TapGestureDetector *)jarg1;
42645   {
42646     try {
42647       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42648     } catch (std::out_of_range& e) {
42649       {
42650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (std::exception& e) {
42653       {
42654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42655       };
42656     } catch (Dali::DaliException e) {
42657       {
42658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42659       };
42660     } catch (...) {
42661       {
42662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42663       };
42664     }
42665   }
42666
42667   jresult = (void *)result;
42668   return jresult;
42669 }
42670
42671
42672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42673   void * jresult ;
42674   Dali::TapGesture *result = 0 ;
42675
42676   {
42677     try {
42678       result = (Dali::TapGesture *)new Dali::TapGesture();
42679     } catch (std::out_of_range& e) {
42680       {
42681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42682       };
42683     } catch (std::exception& e) {
42684       {
42685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42686       };
42687     } catch (Dali::DaliException e) {
42688       {
42689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42690       };
42691     } catch (...) {
42692       {
42693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42694       };
42695     }
42696   }
42697
42698   jresult = (void *)result;
42699   return jresult;
42700 }
42701
42702
42703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42704   void * jresult ;
42705   Dali::TapGesture *arg1 = 0 ;
42706   Dali::TapGesture *result = 0 ;
42707
42708   arg1 = (Dali::TapGesture *)jarg1;
42709   if (!arg1) {
42710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42711     return 0;
42712   }
42713   {
42714     try {
42715       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42716     } catch (std::out_of_range& e) {
42717       {
42718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42719       };
42720     } catch (std::exception& e) {
42721       {
42722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42723       };
42724     } catch (Dali::DaliException e) {
42725       {
42726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42727       };
42728     } catch (...) {
42729       {
42730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42731       };
42732     }
42733   }
42734
42735   jresult = (void *)result;
42736   return jresult;
42737 }
42738
42739
42740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42741   void * jresult ;
42742   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42743   Dali::TapGesture *arg2 = 0 ;
42744   Dali::TapGesture *result = 0 ;
42745
42746   arg1 = (Dali::TapGesture *)jarg1;
42747   arg2 = (Dali::TapGesture *)jarg2;
42748   if (!arg2) {
42749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42750     return 0;
42751   }
42752   {
42753     try {
42754       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42755     } catch (std::out_of_range& e) {
42756       {
42757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42758       };
42759     } catch (std::exception& e) {
42760       {
42761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42762       };
42763     } catch (Dali::DaliException e) {
42764       {
42765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42766       };
42767     } catch (...) {
42768       {
42769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42770       };
42771     }
42772   }
42773
42774   jresult = (void *)result;
42775   return jresult;
42776 }
42777
42778
42779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42780   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42781
42782   arg1 = (Dali::TapGesture *)jarg1;
42783   {
42784     try {
42785       delete arg1;
42786     } catch (std::out_of_range& e) {
42787       {
42788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42789       };
42790     } catch (std::exception& e) {
42791       {
42792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42793       };
42794     } catch (Dali::DaliException e) {
42795       {
42796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42797       };
42798     } catch (...) {
42799       {
42800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42801       };
42802     }
42803   }
42804
42805 }
42806
42807
42808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42809   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42810   unsigned int arg2 ;
42811
42812   arg1 = (Dali::TapGesture *)jarg1;
42813   arg2 = (unsigned int)jarg2;
42814   if (arg1) (arg1)->numberOfTaps = arg2;
42815 }
42816
42817
42818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42819   unsigned int jresult ;
42820   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42821   unsigned int result;
42822
42823   arg1 = (Dali::TapGesture *)jarg1;
42824   result = (unsigned int) ((arg1)->numberOfTaps);
42825   jresult = result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42831   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42832   unsigned int arg2 ;
42833
42834   arg1 = (Dali::TapGesture *)jarg1;
42835   arg2 = (unsigned int)jarg2;
42836   if (arg1) (arg1)->numberOfTouches = arg2;
42837 }
42838
42839
42840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42841   unsigned int jresult ;
42842   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42843   unsigned int result;
42844
42845   arg1 = (Dali::TapGesture *)jarg1;
42846   result = (unsigned int) ((arg1)->numberOfTouches);
42847   jresult = result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42854   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42855
42856   arg1 = (Dali::TapGesture *)jarg1;
42857   arg2 = (Dali::Vector2 *)jarg2;
42858   if (arg1) (arg1)->screenPoint = *arg2;
42859 }
42860
42861
42862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42863   void * jresult ;
42864   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42865   Dali::Vector2 *result = 0 ;
42866
42867   arg1 = (Dali::TapGesture *)jarg1;
42868   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42869   jresult = (void *)result;
42870   return jresult;
42871 }
42872
42873
42874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42875   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42876   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42877
42878   arg1 = (Dali::TapGesture *)jarg1;
42879   arg2 = (Dali::Vector2 *)jarg2;
42880   if (arg1) (arg1)->localPoint = *arg2;
42881 }
42882
42883
42884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42885   void * jresult ;
42886   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42887   Dali::Vector2 *result = 0 ;
42888
42889   arg1 = (Dali::TapGesture *)jarg1;
42890   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42897   void * jresult ;
42898   Dali::AlphaFunction *result = 0 ;
42899
42900   {
42901     try {
42902       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42903     } catch (std::out_of_range& e) {
42904       {
42905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42906       };
42907     } catch (std::exception& e) {
42908       {
42909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42910       };
42911     } catch (Dali::DaliException e) {
42912       {
42913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42914       };
42915     } catch (...) {
42916       {
42917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42918       };
42919     }
42920   }
42921
42922   jresult = (void *)result;
42923   return jresult;
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42928   void * jresult ;
42929   Dali::AlphaFunction::BuiltinFunction arg1 ;
42930   Dali::AlphaFunction *result = 0 ;
42931
42932   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42933   {
42934     try {
42935       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42936     } catch (std::out_of_range& e) {
42937       {
42938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42939       };
42940     } catch (std::exception& e) {
42941       {
42942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42943       };
42944     } catch (Dali::DaliException e) {
42945       {
42946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42951       };
42952     }
42953   }
42954
42955   jresult = (void *)result;
42956   return jresult;
42957 }
42958
42959
42960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42961   void * jresult ;
42962   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42963   Dali::AlphaFunction *result = 0 ;
42964
42965   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42966   {
42967     try {
42968       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42969     } catch (std::out_of_range& e) {
42970       {
42971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (std::exception& e) {
42974       {
42975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (Dali::DaliException e) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42980       };
42981     } catch (...) {
42982       {
42983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42984       };
42985     }
42986   }
42987
42988   jresult = (void *)result;
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42994   void * jresult ;
42995   Dali::Vector2 *arg1 = 0 ;
42996   Dali::Vector2 *arg2 = 0 ;
42997   Dali::AlphaFunction *result = 0 ;
42998
42999   arg1 = (Dali::Vector2 *)jarg1;
43000   if (!arg1) {
43001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43002     return 0;
43003   }
43004   arg2 = (Dali::Vector2 *)jarg2;
43005   if (!arg2) {
43006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43007     return 0;
43008   }
43009   {
43010     try {
43011       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43012     } catch (std::out_of_range& e) {
43013       {
43014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43015       };
43016     } catch (std::exception& e) {
43017       {
43018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43019       };
43020     } catch (Dali::DaliException e) {
43021       {
43022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43023       };
43024     } catch (...) {
43025       {
43026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43027       };
43028     }
43029   }
43030
43031   jresult = (void *)result;
43032   return jresult;
43033 }
43034
43035
43036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43037   void * jresult ;
43038   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43039   Dali::Vector4 result;
43040
43041   arg1 = (Dali::AlphaFunction *)jarg1;
43042   {
43043     try {
43044       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43045     } catch (std::out_of_range& e) {
43046       {
43047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (std::exception& e) {
43050       {
43051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43052       };
43053     } catch (Dali::DaliException e) {
43054       {
43055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43056       };
43057     } catch (...) {
43058       {
43059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43060       };
43061     }
43062   }
43063
43064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43065   return jresult;
43066 }
43067
43068
43069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43070   void * jresult ;
43071   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43072   Dali::AlphaFunctionPrototype result;
43073
43074   arg1 = (Dali::AlphaFunction *)jarg1;
43075   {
43076     try {
43077       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43078     } catch (std::out_of_range& e) {
43079       {
43080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43081       };
43082     } catch (std::exception& e) {
43083       {
43084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43085       };
43086     } catch (Dali::DaliException e) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43089       };
43090     } catch (...) {
43091       {
43092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43093       };
43094     }
43095   }
43096
43097   jresult = (void *)result;
43098   return jresult;
43099 }
43100
43101
43102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43103   int jresult ;
43104   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43105   Dali::AlphaFunction::BuiltinFunction result;
43106
43107   arg1 = (Dali::AlphaFunction *)jarg1;
43108   {
43109     try {
43110       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43111     } catch (std::out_of_range& e) {
43112       {
43113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43114       };
43115     } catch (std::exception& e) {
43116       {
43117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43118       };
43119     } catch (Dali::DaliException e) {
43120       {
43121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43122       };
43123     } catch (...) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43126       };
43127     }
43128   }
43129
43130   jresult = (int)result;
43131   return jresult;
43132 }
43133
43134
43135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43136   int jresult ;
43137   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43138   Dali::AlphaFunction::Mode result;
43139
43140   arg1 = (Dali::AlphaFunction *)jarg1;
43141   {
43142     try {
43143       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43144     } catch (std::out_of_range& e) {
43145       {
43146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43147       };
43148     } catch (std::exception& e) {
43149       {
43150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43151       };
43152     } catch (Dali::DaliException e) {
43153       {
43154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43155       };
43156     } catch (...) {
43157       {
43158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43159       };
43160     }
43161   }
43162
43163   jresult = (int)result;
43164   return jresult;
43165 }
43166
43167
43168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43169   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43170
43171   arg1 = (Dali::AlphaFunction *)jarg1;
43172   {
43173     try {
43174       delete arg1;
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (Dali::DaliException e) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43190       };
43191     }
43192   }
43193
43194 }
43195
43196
43197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43198   void * jresult ;
43199   Dali::KeyFrames result;
43200
43201   {
43202     try {
43203       result = Dali::KeyFrames::New();
43204     } catch (std::out_of_range& e) {
43205       {
43206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43207       };
43208     } catch (std::exception& e) {
43209       {
43210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43211       };
43212     } catch (Dali::DaliException e) {
43213       {
43214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43215       };
43216     } catch (...) {
43217       {
43218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43219       };
43220     }
43221   }
43222
43223   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43224   return jresult;
43225 }
43226
43227
43228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43229   void * jresult ;
43230   Dali::BaseHandle arg1 ;
43231   Dali::BaseHandle *argp1 ;
43232   Dali::KeyFrames result;
43233
43234   argp1 = (Dali::BaseHandle *)jarg1;
43235   if (!argp1) {
43236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43237     return 0;
43238   }
43239   arg1 = *argp1;
43240   {
43241     try {
43242       result = Dali::KeyFrames::DownCast(arg1);
43243     } catch (std::out_of_range& e) {
43244       {
43245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43246       };
43247     } catch (std::exception& e) {
43248       {
43249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43250       };
43251     } catch (Dali::DaliException e) {
43252       {
43253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43254       };
43255     } catch (...) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43258       };
43259     }
43260   }
43261
43262   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43263   return jresult;
43264 }
43265
43266
43267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43268   void * jresult ;
43269   Dali::KeyFrames *result = 0 ;
43270
43271   {
43272     try {
43273       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43274     } catch (std::out_of_range& e) {
43275       {
43276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43277       };
43278     } catch (std::exception& e) {
43279       {
43280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43281       };
43282     } catch (Dali::DaliException e) {
43283       {
43284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43285       };
43286     } catch (...) {
43287       {
43288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43289       };
43290     }
43291   }
43292
43293   jresult = (void *)result;
43294   return jresult;
43295 }
43296
43297
43298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43299   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43300
43301   arg1 = (Dali::KeyFrames *)jarg1;
43302   {
43303     try {
43304       delete arg1;
43305     } catch (std::out_of_range& e) {
43306       {
43307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43308       };
43309     } catch (std::exception& e) {
43310       {
43311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43312       };
43313     } catch (Dali::DaliException e) {
43314       {
43315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43316       };
43317     } catch (...) {
43318       {
43319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43320       };
43321     }
43322   }
43323
43324 }
43325
43326
43327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43328   void * jresult ;
43329   Dali::KeyFrames *arg1 = 0 ;
43330   Dali::KeyFrames *result = 0 ;
43331
43332   arg1 = (Dali::KeyFrames *)jarg1;
43333   if (!arg1) {
43334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43335     return 0;
43336   }
43337   {
43338     try {
43339       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43340     } catch (std::out_of_range& e) {
43341       {
43342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43343       };
43344     } catch (std::exception& e) {
43345       {
43346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43347       };
43348     } catch (Dali::DaliException e) {
43349       {
43350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43351       };
43352     } catch (...) {
43353       {
43354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43355       };
43356     }
43357   }
43358
43359   jresult = (void *)result;
43360   return jresult;
43361 }
43362
43363
43364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43365   void * jresult ;
43366   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43367   Dali::KeyFrames *arg2 = 0 ;
43368   Dali::KeyFrames *result = 0 ;
43369
43370   arg1 = (Dali::KeyFrames *)jarg1;
43371   arg2 = (Dali::KeyFrames *)jarg2;
43372   if (!arg2) {
43373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43374     return 0;
43375   }
43376   {
43377     try {
43378       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (Dali::DaliException e) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43390       };
43391     } catch (...) {
43392       {
43393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43394       };
43395     }
43396   }
43397
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43404   int jresult ;
43405   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43406   Dali::Property::Type result;
43407
43408   arg1 = (Dali::KeyFrames *)jarg1;
43409   {
43410     try {
43411       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43427       };
43428     }
43429   }
43430
43431   jresult = (int)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43437   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43438   float arg2 ;
43439   Dali::Property::Value arg3 ;
43440   Dali::Property::Value *argp3 ;
43441
43442   arg1 = (Dali::KeyFrames *)jarg1;
43443   arg2 = (float)jarg2;
43444   argp3 = (Dali::Property::Value *)jarg3;
43445   if (!argp3) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43447     return ;
43448   }
43449   arg3 = *argp3;
43450   {
43451     try {
43452       (arg1)->Add(arg2,arg3);
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43468       };
43469     }
43470   }
43471
43472 }
43473
43474
43475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43476   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43477   float arg2 ;
43478   Dali::Property::Value arg3 ;
43479   Dali::AlphaFunction arg4 ;
43480   Dali::Property::Value *argp3 ;
43481   Dali::AlphaFunction *argp4 ;
43482
43483   arg1 = (Dali::KeyFrames *)jarg1;
43484   arg2 = (float)jarg2;
43485   argp3 = (Dali::Property::Value *)jarg3;
43486   if (!argp3) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43488     return ;
43489   }
43490   arg3 = *argp3;
43491   argp4 = (Dali::AlphaFunction *)jarg4;
43492   if (!argp4) {
43493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43494     return ;
43495   }
43496   arg4 = *argp4;
43497   {
43498     try {
43499       (arg1)->Add(arg2,arg3,arg4);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43507       };
43508     } catch (Dali::DaliException e) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43511       };
43512     } catch (...) {
43513       {
43514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43515       };
43516     }
43517   }
43518
43519 }
43520
43521
43522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43523   int jresult ;
43524   int result;
43525
43526   result = (int)Dali::Path::Property::POINTS;
43527   jresult = (int)result;
43528   return jresult;
43529 }
43530
43531
43532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43533   int jresult ;
43534   int result;
43535
43536   result = (int)Dali::Path::Property::CONTROL_POINTS;
43537   jresult = (int)result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43543   void * jresult ;
43544   Dali::Path::Property *result = 0 ;
43545
43546   {
43547     try {
43548       result = (Dali::Path::Property *)new Dali::Path::Property();
43549     } catch (std::out_of_range& e) {
43550       {
43551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43552       };
43553     } catch (std::exception& e) {
43554       {
43555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43556       };
43557     } catch (Dali::DaliException e) {
43558       {
43559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43560       };
43561     } catch (...) {
43562       {
43563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43564       };
43565     }
43566   }
43567
43568   jresult = (void *)result;
43569   return jresult;
43570 }
43571
43572
43573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43574   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43575
43576   arg1 = (Dali::Path::Property *)jarg1;
43577   {
43578     try {
43579       delete arg1;
43580     } catch (std::out_of_range& e) {
43581       {
43582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43583       };
43584     } catch (std::exception& e) {
43585       {
43586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43587       };
43588     } catch (Dali::DaliException e) {
43589       {
43590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43591       };
43592     } catch (...) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43595       };
43596     }
43597   }
43598
43599 }
43600
43601
43602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43603   void * jresult ;
43604   Dali::Path result;
43605
43606   {
43607     try {
43608       result = Dali::Path::New();
43609     } catch (std::out_of_range& e) {
43610       {
43611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43612       };
43613     } catch (std::exception& e) {
43614       {
43615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43616       };
43617     } catch (Dali::DaliException e) {
43618       {
43619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43620       };
43621     } catch (...) {
43622       {
43623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43624       };
43625     }
43626   }
43627
43628   jresult = new Dali::Path((const Dali::Path &)result);
43629   return jresult;
43630 }
43631
43632
43633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43634   void * jresult ;
43635   Dali::BaseHandle arg1 ;
43636   Dali::BaseHandle *argp1 ;
43637   Dali::Path result;
43638
43639   argp1 = (Dali::BaseHandle *)jarg1;
43640   if (!argp1) {
43641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43642     return 0;
43643   }
43644   arg1 = *argp1;
43645   {
43646     try {
43647       result = Dali::Path::DownCast(arg1);
43648     } catch (std::out_of_range& e) {
43649       {
43650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43651       };
43652     } catch (std::exception& e) {
43653       {
43654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43655       };
43656     } catch (Dali::DaliException e) {
43657       {
43658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43663       };
43664     }
43665   }
43666
43667   jresult = new Dali::Path((const Dali::Path &)result);
43668   return jresult;
43669 }
43670
43671
43672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43673   void * jresult ;
43674   Dali::Path *result = 0 ;
43675
43676   {
43677     try {
43678       result = (Dali::Path *)new Dali::Path();
43679     } catch (std::out_of_range& e) {
43680       {
43681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43682       };
43683     } catch (std::exception& e) {
43684       {
43685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (Dali::DaliException e) {
43688       {
43689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697
43698   jresult = (void *)result;
43699   return jresult;
43700 }
43701
43702
43703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43704   Dali::Path *arg1 = (Dali::Path *) 0 ;
43705
43706   arg1 = (Dali::Path *)jarg1;
43707   {
43708     try {
43709       delete arg1;
43710     } catch (std::out_of_range& e) {
43711       {
43712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43713       };
43714     } catch (std::exception& e) {
43715       {
43716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43717       };
43718     } catch (Dali::DaliException e) {
43719       {
43720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43721       };
43722     } catch (...) {
43723       {
43724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43725       };
43726     }
43727   }
43728
43729 }
43730
43731
43732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43733   void * jresult ;
43734   Dali::Path *arg1 = 0 ;
43735   Dali::Path *result = 0 ;
43736
43737   arg1 = (Dali::Path *)jarg1;
43738   if (!arg1) {
43739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43740     return 0;
43741   }
43742   {
43743     try {
43744       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43745     } catch (std::out_of_range& e) {
43746       {
43747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43748       };
43749     } catch (std::exception& e) {
43750       {
43751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43752       };
43753     } catch (Dali::DaliException e) {
43754       {
43755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43756       };
43757     } catch (...) {
43758       {
43759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43760       };
43761     }
43762   }
43763
43764   jresult = (void *)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43770   void * jresult ;
43771   Dali::Path *arg1 = (Dali::Path *) 0 ;
43772   Dali::Path *arg2 = 0 ;
43773   Dali::Path *result = 0 ;
43774
43775   arg1 = (Dali::Path *)jarg1;
43776   arg2 = (Dali::Path *)jarg2;
43777   if (!arg2) {
43778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43779     return 0;
43780   }
43781   {
43782     try {
43783       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43784     } catch (std::out_of_range& e) {
43785       {
43786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43787       };
43788     } catch (std::exception& e) {
43789       {
43790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43791       };
43792     } catch (Dali::DaliException e) {
43793       {
43794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43795       };
43796     } catch (...) {
43797       {
43798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43799       };
43800     }
43801   }
43802
43803   jresult = (void *)result;
43804   return jresult;
43805 }
43806
43807
43808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43809   Dali::Path *arg1 = (Dali::Path *) 0 ;
43810   Dali::Vector3 *arg2 = 0 ;
43811
43812   arg1 = (Dali::Path *)jarg1;
43813   arg2 = (Dali::Vector3 *)jarg2;
43814   if (!arg2) {
43815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43816     return ;
43817   }
43818   {
43819     try {
43820       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43821     } catch (std::out_of_range& e) {
43822       {
43823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43824       };
43825     } catch (std::exception& e) {
43826       {
43827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43828       };
43829     } catch (Dali::DaliException e) {
43830       {
43831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43832       };
43833     } catch (...) {
43834       {
43835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43836       };
43837     }
43838   }
43839
43840 }
43841
43842
43843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43844   Dali::Path *arg1 = (Dali::Path *) 0 ;
43845   Dali::Vector3 *arg2 = 0 ;
43846
43847   arg1 = (Dali::Path *)jarg1;
43848   arg2 = (Dali::Vector3 *)jarg2;
43849   if (!arg2) {
43850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43851     return ;
43852   }
43853   {
43854     try {
43855       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43856     } catch (std::out_of_range& e) {
43857       {
43858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43859       };
43860     } catch (std::exception& e) {
43861       {
43862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43863       };
43864     } catch (Dali::DaliException e) {
43865       {
43866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43867       };
43868     } catch (...) {
43869       {
43870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43871       };
43872     }
43873   }
43874
43875 }
43876
43877
43878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43879   Dali::Path *arg1 = (Dali::Path *) 0 ;
43880   float arg2 ;
43881
43882   arg1 = (Dali::Path *)jarg1;
43883   arg2 = (float)jarg2;
43884   {
43885     try {
43886       (arg1)->GenerateControlPoints(arg2);
43887     } catch (std::out_of_range& e) {
43888       {
43889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43890       };
43891     } catch (std::exception& e) {
43892       {
43893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43894       };
43895     } catch (Dali::DaliException e) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43902       };
43903     }
43904   }
43905
43906 }
43907
43908
43909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43910   Dali::Path *arg1 = (Dali::Path *) 0 ;
43911   float arg2 ;
43912   Dali::Vector3 *arg3 = 0 ;
43913   Dali::Vector3 *arg4 = 0 ;
43914
43915   arg1 = (Dali::Path *)jarg1;
43916   arg2 = (float)jarg2;
43917   arg3 = (Dali::Vector3 *)jarg3;
43918   if (!arg3) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43920     return ;
43921   }
43922   arg4 = (Dali::Vector3 *)jarg4;
43923   if (!arg4) {
43924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43925     return ;
43926   }
43927   {
43928     try {
43929       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43930     } catch (std::out_of_range& e) {
43931       {
43932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43933       };
43934     } catch (std::exception& e) {
43935       {
43936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43937       };
43938     } catch (Dali::DaliException e) {
43939       {
43940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43941       };
43942     } catch (...) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43945       };
43946     }
43947   }
43948
43949 }
43950
43951
43952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43953   void * jresult ;
43954   Dali::Path *arg1 = (Dali::Path *) 0 ;
43955   size_t arg2 ;
43956   Dali::Vector3 *result = 0 ;
43957
43958   arg1 = (Dali::Path *)jarg1;
43959   arg2 = (size_t)jarg2;
43960   {
43961     try {
43962       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43963     } catch (std::out_of_range& e) {
43964       {
43965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43966       };
43967     } catch (std::exception& e) {
43968       {
43969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43970       };
43971     } catch (Dali::DaliException e) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43974       };
43975     } catch (...) {
43976       {
43977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43978       };
43979     }
43980   }
43981
43982   jresult = (void *)result;
43983   return jresult;
43984 }
43985
43986
43987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43988   void * jresult ;
43989   Dali::Path *arg1 = (Dali::Path *) 0 ;
43990   size_t arg2 ;
43991   Dali::Vector3 *result = 0 ;
43992
43993   arg1 = (Dali::Path *)jarg1;
43994   arg2 = (size_t)jarg2;
43995   {
43996     try {
43997       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43998     } catch (std::out_of_range& e) {
43999       {
44000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (std::exception& e) {
44003       {
44004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44005       };
44006     } catch (Dali::DaliException e) {
44007       {
44008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44009       };
44010     } catch (...) {
44011       {
44012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44013       };
44014     }
44015   }
44016
44017   jresult = (void *)result;
44018   return jresult;
44019 }
44020
44021
44022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44023   unsigned long jresult ;
44024   Dali::Path *arg1 = (Dali::Path *) 0 ;
44025   size_t result;
44026
44027   arg1 = (Dali::Path *)jarg1;
44028   {
44029     try {
44030       result = ((Dali::Path const *)arg1)->GetPointCount();
44031     } catch (std::out_of_range& e) {
44032       {
44033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44034       };
44035     } catch (std::exception& e) {
44036       {
44037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44038       };
44039     } catch (Dali::DaliException e) {
44040       {
44041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44042       };
44043     } catch (...) {
44044       {
44045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44046       };
44047     }
44048   }
44049
44050   jresult = (unsigned long)result;
44051   return jresult;
44052 }
44053
44054
44055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44056   void * jresult ;
44057   float arg1 ;
44058   Dali::TimePeriod *result = 0 ;
44059
44060   arg1 = (float)jarg1;
44061   {
44062     try {
44063       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44064     } catch (std::out_of_range& e) {
44065       {
44066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44067       };
44068     } catch (std::exception& e) {
44069       {
44070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44071       };
44072     } catch (Dali::DaliException e) {
44073       {
44074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44075       };
44076     } catch (...) {
44077       {
44078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44079       };
44080     }
44081   }
44082
44083   jresult = (void *)result;
44084   return jresult;
44085 }
44086
44087
44088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44089   void * jresult ;
44090   float arg1 ;
44091   float arg2 ;
44092   Dali::TimePeriod *result = 0 ;
44093
44094   arg1 = (float)jarg1;
44095   arg2 = (float)jarg2;
44096   {
44097     try {
44098       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44099     } catch (std::out_of_range& e) {
44100       {
44101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44102       };
44103     } catch (std::exception& e) {
44104       {
44105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44106       };
44107     } catch (Dali::DaliException e) {
44108       {
44109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44110       };
44111     } catch (...) {
44112       {
44113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44114       };
44115     }
44116   }
44117
44118   jresult = (void *)result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44124   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44125
44126   arg1 = (Dali::TimePeriod *)jarg1;
44127   {
44128     try {
44129       delete arg1;
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44137       };
44138     } catch (Dali::DaliException e) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44145       };
44146     }
44147   }
44148
44149 }
44150
44151
44152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44153   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44154   float arg2 ;
44155
44156   arg1 = (Dali::TimePeriod *)jarg1;
44157   arg2 = (float)jarg2;
44158   if (arg1) (arg1)->delaySeconds = arg2;
44159 }
44160
44161
44162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44163   float jresult ;
44164   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44165   float result;
44166
44167   arg1 = (Dali::TimePeriod *)jarg1;
44168   result = (float) ((arg1)->delaySeconds);
44169   jresult = result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44175   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44176   float arg2 ;
44177
44178   arg1 = (Dali::TimePeriod *)jarg1;
44179   arg2 = (float)jarg2;
44180   if (arg1) (arg1)->durationSeconds = arg2;
44181 }
44182
44183
44184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44185   float jresult ;
44186   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44187   float result;
44188
44189   arg1 = (Dali::TimePeriod *)jarg1;
44190   result = (float) ((arg1)->durationSeconds);
44191   jresult = result;
44192   return jresult;
44193 }
44194
44195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44196   int jresult ;
44197   int result;
44198
44199   result = (int)Dali::LinearConstrainer::Property::VALUE;
44200   jresult = (int)result;
44201   return jresult;
44202 }
44203
44204
44205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44206   int jresult ;
44207   int result;
44208
44209   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44210   jresult = (int)result;
44211   return jresult;
44212 }
44213
44214
44215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44216   void * jresult ;
44217   Dali::LinearConstrainer::Property *result = 0 ;
44218
44219   {
44220     try {
44221       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44222     } catch (std::out_of_range& e) {
44223       {
44224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44225       };
44226     } catch (std::exception& e) {
44227       {
44228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (Dali::DaliException e) {
44231       {
44232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44233       };
44234     } catch (...) {
44235       {
44236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44237       };
44238     }
44239   }
44240
44241   jresult = (void *)result;
44242   return jresult;
44243 }
44244
44245
44246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44247   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44248
44249   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44250   {
44251     try {
44252       delete arg1;
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44260       };
44261     } catch (Dali::DaliException e) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44264       };
44265     } catch (...) {
44266       {
44267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44268       };
44269     }
44270   }
44271
44272 }
44273
44274
44275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44276   void * jresult ;
44277   Dali::LinearConstrainer result;
44278
44279   {
44280     try {
44281       result = Dali::LinearConstrainer::New();
44282     } catch (std::out_of_range& e) {
44283       {
44284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44285       };
44286     } catch (std::exception& e) {
44287       {
44288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44289       };
44290     } catch (Dali::DaliException e) {
44291       {
44292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44293       };
44294     } catch (...) {
44295       {
44296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44297       };
44298     }
44299   }
44300
44301   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44302   return jresult;
44303 }
44304
44305
44306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44307   void * jresult ;
44308   Dali::BaseHandle arg1 ;
44309   Dali::BaseHandle *argp1 ;
44310   Dali::LinearConstrainer result;
44311
44312   argp1 = (Dali::BaseHandle *)jarg1;
44313   if (!argp1) {
44314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44315     return 0;
44316   }
44317   arg1 = *argp1;
44318   {
44319     try {
44320       result = Dali::LinearConstrainer::DownCast(arg1);
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (Dali::DaliException e) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44336       };
44337     }
44338   }
44339
44340   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44341   return jresult;
44342 }
44343
44344
44345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44346   void * jresult ;
44347   Dali::LinearConstrainer *result = 0 ;
44348
44349   {
44350     try {
44351       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44352     } catch (std::out_of_range& e) {
44353       {
44354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44355       };
44356     } catch (std::exception& e) {
44357       {
44358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44359       };
44360     } catch (Dali::DaliException e) {
44361       {
44362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44363       };
44364     } catch (...) {
44365       {
44366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44367       };
44368     }
44369   }
44370
44371   jresult = (void *)result;
44372   return jresult;
44373 }
44374
44375
44376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44377   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44378
44379   arg1 = (Dali::LinearConstrainer *)jarg1;
44380   {
44381     try {
44382       delete arg1;
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44398       };
44399     }
44400   }
44401
44402 }
44403
44404
44405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44406   void * jresult ;
44407   Dali::LinearConstrainer *arg1 = 0 ;
44408   Dali::LinearConstrainer *result = 0 ;
44409
44410   arg1 = (Dali::LinearConstrainer *)jarg1;
44411   if (!arg1) {
44412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44413     return 0;
44414   }
44415   {
44416     try {
44417       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44418     } catch (std::out_of_range& e) {
44419       {
44420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44421       };
44422     } catch (std::exception& e) {
44423       {
44424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44425       };
44426     } catch (Dali::DaliException e) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44429       };
44430     } catch (...) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44433       };
44434     }
44435   }
44436
44437   jresult = (void *)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44443   void * jresult ;
44444   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44445   Dali::LinearConstrainer *arg2 = 0 ;
44446   Dali::LinearConstrainer *result = 0 ;
44447
44448   arg1 = (Dali::LinearConstrainer *)jarg1;
44449   arg2 = (Dali::LinearConstrainer *)jarg2;
44450   if (!arg2) {
44451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44452     return 0;
44453   }
44454   {
44455     try {
44456       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44457     } catch (std::out_of_range& e) {
44458       {
44459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (std::exception& e) {
44462       {
44463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44464       };
44465     } catch (Dali::DaliException e) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44468       };
44469     } catch (...) {
44470       {
44471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44472       };
44473     }
44474   }
44475
44476   jresult = (void *)result;
44477   return jresult;
44478 }
44479
44480
44481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44482   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44483   SwigValueWrapper< Dali::Property > arg2 ;
44484   SwigValueWrapper< Dali::Property > arg3 ;
44485   Dali::Vector2 *arg4 = 0 ;
44486   Dali::Vector2 *arg5 = 0 ;
44487   Dali::Property *argp2 ;
44488   Dali::Property *argp3 ;
44489
44490   arg1 = (Dali::LinearConstrainer *)jarg1;
44491   argp2 = (Dali::Property *)jarg2;
44492   if (!argp2) {
44493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44494     return ;
44495   }
44496   arg2 = *argp2;
44497   argp3 = (Dali::Property *)jarg3;
44498   if (!argp3) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44500     return ;
44501   }
44502   arg3 = *argp3;
44503   arg4 = (Dali::Vector2 *)jarg4;
44504   if (!arg4) {
44505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44506     return ;
44507   }
44508   arg5 = (Dali::Vector2 *)jarg5;
44509   if (!arg5) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44511     return ;
44512   }
44513   {
44514     try {
44515       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44516     } catch (std::out_of_range& e) {
44517       {
44518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44519       };
44520     } catch (std::exception& e) {
44521       {
44522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44523       };
44524     } catch (Dali::DaliException e) {
44525       {
44526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44527       };
44528     } catch (...) {
44529       {
44530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44531       };
44532     }
44533   }
44534
44535 }
44536
44537
44538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44539   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44540   SwigValueWrapper< Dali::Property > arg2 ;
44541   SwigValueWrapper< Dali::Property > arg3 ;
44542   Dali::Vector2 *arg4 = 0 ;
44543   Dali::Property *argp2 ;
44544   Dali::Property *argp3 ;
44545
44546   arg1 = (Dali::LinearConstrainer *)jarg1;
44547   argp2 = (Dali::Property *)jarg2;
44548   if (!argp2) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44550     return ;
44551   }
44552   arg2 = *argp2;
44553   argp3 = (Dali::Property *)jarg3;
44554   if (!argp3) {
44555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44556     return ;
44557   }
44558   arg3 = *argp3;
44559   arg4 = (Dali::Vector2 *)jarg4;
44560   if (!arg4) {
44561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44562     return ;
44563   }
44564   {
44565     try {
44566       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44567     } catch (std::out_of_range& e) {
44568       {
44569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44570       };
44571     } catch (std::exception& e) {
44572       {
44573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44574       };
44575     } catch (Dali::DaliException e) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44578       };
44579     } catch (...) {
44580       {
44581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44582       };
44583     }
44584   }
44585
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44590   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44591   Dali::Handle *arg2 = 0 ;
44592
44593   arg1 = (Dali::LinearConstrainer *)jarg1;
44594   arg2 = (Dali::Handle *)jarg2;
44595   if (!arg2) {
44596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44597     return ;
44598   }
44599   {
44600     try {
44601       (arg1)->Remove(*arg2);
44602     } catch (std::out_of_range& e) {
44603       {
44604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44605       };
44606     } catch (std::exception& e) {
44607       {
44608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44609       };
44610     } catch (Dali::DaliException e) {
44611       {
44612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44613       };
44614     } catch (...) {
44615       {
44616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44617       };
44618     }
44619   }
44620
44621 }
44622
44623
44624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44625   int jresult ;
44626   int result;
44627
44628   result = (int)Dali::PathConstrainer::Property::FORWARD;
44629   jresult = (int)result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44635   int jresult ;
44636   int result;
44637
44638   result = (int)Dali::PathConstrainer::Property::POINTS;
44639   jresult = (int)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44645   int jresult ;
44646   int result;
44647
44648   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44649   jresult = (int)result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44655   void * jresult ;
44656   Dali::PathConstrainer::Property *result = 0 ;
44657
44658   {
44659     try {
44660       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44661     } catch (std::out_of_range& e) {
44662       {
44663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44664       };
44665     } catch (std::exception& e) {
44666       {
44667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44668       };
44669     } catch (Dali::DaliException e) {
44670       {
44671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44672       };
44673     } catch (...) {
44674       {
44675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44676       };
44677     }
44678   }
44679
44680   jresult = (void *)result;
44681   return jresult;
44682 }
44683
44684
44685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44686   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44687
44688   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44689   {
44690     try {
44691       delete arg1;
44692     } catch (std::out_of_range& e) {
44693       {
44694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44695       };
44696     } catch (std::exception& e) {
44697       {
44698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44699       };
44700     } catch (Dali::DaliException e) {
44701       {
44702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44703       };
44704     } catch (...) {
44705       {
44706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44707       };
44708     }
44709   }
44710
44711 }
44712
44713
44714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44715   void * jresult ;
44716   Dali::PathConstrainer result;
44717
44718   {
44719     try {
44720       result = Dali::PathConstrainer::New();
44721     } catch (std::out_of_range& e) {
44722       {
44723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44724       };
44725     } catch (std::exception& e) {
44726       {
44727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44728       };
44729     } catch (Dali::DaliException e) {
44730       {
44731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44732       };
44733     } catch (...) {
44734       {
44735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44736       };
44737     }
44738   }
44739
44740   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44741   return jresult;
44742 }
44743
44744
44745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44746   void * jresult ;
44747   Dali::BaseHandle arg1 ;
44748   Dali::BaseHandle *argp1 ;
44749   Dali::PathConstrainer result;
44750
44751   argp1 = (Dali::BaseHandle *)jarg1;
44752   if (!argp1) {
44753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44754     return 0;
44755   }
44756   arg1 = *argp1;
44757   {
44758     try {
44759       result = Dali::PathConstrainer::DownCast(arg1);
44760     } catch (std::out_of_range& e) {
44761       {
44762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (std::exception& e) {
44765       {
44766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44767       };
44768     } catch (Dali::DaliException e) {
44769       {
44770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44771       };
44772     } catch (...) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44775       };
44776     }
44777   }
44778
44779   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44780   return jresult;
44781 }
44782
44783
44784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44785   void * jresult ;
44786   Dali::PathConstrainer *result = 0 ;
44787
44788   {
44789     try {
44790       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44791     } catch (std::out_of_range& e) {
44792       {
44793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44794       };
44795     } catch (std::exception& e) {
44796       {
44797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44798       };
44799     } catch (Dali::DaliException e) {
44800       {
44801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44802       };
44803     } catch (...) {
44804       {
44805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44806       };
44807     }
44808   }
44809
44810   jresult = (void *)result;
44811   return jresult;
44812 }
44813
44814
44815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44816   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44817
44818   arg1 = (Dali::PathConstrainer *)jarg1;
44819   {
44820     try {
44821       delete arg1;
44822     } catch (std::out_of_range& e) {
44823       {
44824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44825       };
44826     } catch (std::exception& e) {
44827       {
44828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (Dali::DaliException e) {
44831       {
44832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44845   void * jresult ;
44846   Dali::PathConstrainer *arg1 = 0 ;
44847   Dali::PathConstrainer *result = 0 ;
44848
44849   arg1 = (Dali::PathConstrainer *)jarg1;
44850   if (!arg1) {
44851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44852     return 0;
44853   }
44854   {
44855     try {
44856       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44857     } catch (std::out_of_range& e) {
44858       {
44859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (std::exception& e) {
44862       {
44863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44864       };
44865     } catch (Dali::DaliException e) {
44866       {
44867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44868       };
44869     } catch (...) {
44870       {
44871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44872       };
44873     }
44874   }
44875
44876   jresult = (void *)result;
44877   return jresult;
44878 }
44879
44880
44881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44882   void * jresult ;
44883   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44884   Dali::PathConstrainer *arg2 = 0 ;
44885   Dali::PathConstrainer *result = 0 ;
44886
44887   arg1 = (Dali::PathConstrainer *)jarg1;
44888   arg2 = (Dali::PathConstrainer *)jarg2;
44889   if (!arg2) {
44890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44891     return 0;
44892   }
44893   {
44894     try {
44895       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44896     } catch (std::out_of_range& e) {
44897       {
44898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44899       };
44900     } catch (std::exception& e) {
44901       {
44902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44903       };
44904     } catch (Dali::DaliException e) {
44905       {
44906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44907       };
44908     } catch (...) {
44909       {
44910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44911       };
44912     }
44913   }
44914
44915   jresult = (void *)result;
44916   return jresult;
44917 }
44918
44919
44920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44921   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44922   SwigValueWrapper< Dali::Property > arg2 ;
44923   SwigValueWrapper< Dali::Property > arg3 ;
44924   Dali::Vector2 *arg4 = 0 ;
44925   Dali::Vector2 *arg5 = 0 ;
44926   Dali::Property *argp2 ;
44927   Dali::Property *argp3 ;
44928
44929   arg1 = (Dali::PathConstrainer *)jarg1;
44930   argp2 = (Dali::Property *)jarg2;
44931   if (!argp2) {
44932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44933     return ;
44934   }
44935   arg2 = *argp2;
44936   argp3 = (Dali::Property *)jarg3;
44937   if (!argp3) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44939     return ;
44940   }
44941   arg3 = *argp3;
44942   arg4 = (Dali::Vector2 *)jarg4;
44943   if (!arg4) {
44944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44945     return ;
44946   }
44947   arg5 = (Dali::Vector2 *)jarg5;
44948   if (!arg5) {
44949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44950     return ;
44951   }
44952   {
44953     try {
44954       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44955     } catch (std::out_of_range& e) {
44956       {
44957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44958       };
44959     } catch (std::exception& e) {
44960       {
44961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44962       };
44963     } catch (Dali::DaliException e) {
44964       {
44965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44966       };
44967     } catch (...) {
44968       {
44969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44970       };
44971     }
44972   }
44973
44974 }
44975
44976
44977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44978   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44979   SwigValueWrapper< Dali::Property > arg2 ;
44980   SwigValueWrapper< Dali::Property > arg3 ;
44981   Dali::Vector2 *arg4 = 0 ;
44982   Dali::Property *argp2 ;
44983   Dali::Property *argp3 ;
44984
44985   arg1 = (Dali::PathConstrainer *)jarg1;
44986   argp2 = (Dali::Property *)jarg2;
44987   if (!argp2) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44989     return ;
44990   }
44991   arg2 = *argp2;
44992   argp3 = (Dali::Property *)jarg3;
44993   if (!argp3) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44995     return ;
44996   }
44997   arg3 = *argp3;
44998   arg4 = (Dali::Vector2 *)jarg4;
44999   if (!arg4) {
45000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45001     return ;
45002   }
45003   {
45004     try {
45005       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45006     } catch (std::out_of_range& e) {
45007       {
45008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45009       };
45010     } catch (std::exception& e) {
45011       {
45012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45013       };
45014     } catch (Dali::DaliException e) {
45015       {
45016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45017       };
45018     } catch (...) {
45019       {
45020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45021       };
45022     }
45023   }
45024
45025 }
45026
45027
45028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45029   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45030   Dali::Handle *arg2 = 0 ;
45031
45032   arg1 = (Dali::PathConstrainer *)jarg1;
45033   arg2 = (Dali::Handle *)jarg2;
45034   if (!arg2) {
45035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45036     return ;
45037   }
45038   {
45039     try {
45040       (arg1)->Remove(*arg2);
45041     } catch (std::out_of_range& e) {
45042       {
45043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45044       };
45045     } catch (std::exception& e) {
45046       {
45047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (Dali::DaliException e) {
45050       {
45051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059
45060 }
45061
45062
45063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45064   int jresult ;
45065   Dali::FittingMode::Type result;
45066
45067   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45068   jresult = (int)result;
45069   return jresult;
45070 }
45071
45072
45073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45074   int jresult ;
45075   Dali::SamplingMode::Type result;
45076
45077   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45078   jresult = (int)result;
45079   return jresult;
45080 }
45081
45082
45083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45084   void * jresult ;
45085   Dali::BufferImage *result = 0 ;
45086
45087   {
45088     try {
45089       result = (Dali::BufferImage *)new Dali::BufferImage();
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (Dali::DaliException e) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45101       };
45102     } catch (...) {
45103       {
45104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45105       };
45106     }
45107   }
45108
45109   jresult = (void *)result;
45110   return jresult;
45111 }
45112
45113
45114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45115   void * jresult ;
45116   unsigned int arg1 ;
45117   unsigned int arg2 ;
45118   Dali::Pixel::Format arg3 ;
45119   Dali::BufferImage result;
45120
45121   arg1 = (unsigned int)jarg1;
45122   arg2 = (unsigned int)jarg2;
45123   arg3 = (Dali::Pixel::Format)jarg3;
45124   {
45125     try {
45126       result = Dali::BufferImage::New(arg1,arg2,arg3);
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (Dali::DaliException e) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45138       };
45139     } catch (...) {
45140       {
45141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45142       };
45143     }
45144   }
45145
45146   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45147   return jresult;
45148 }
45149
45150
45151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45152   void * jresult ;
45153   unsigned int arg1 ;
45154   unsigned int arg2 ;
45155   Dali::BufferImage result;
45156
45157   arg1 = (unsigned int)jarg1;
45158   arg2 = (unsigned int)jarg2;
45159   {
45160     try {
45161       result = Dali::BufferImage::New(arg1,arg2);
45162     } catch (std::out_of_range& e) {
45163       {
45164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45165       };
45166     } catch (std::exception& e) {
45167       {
45168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45169       };
45170     } catch (Dali::DaliException e) {
45171       {
45172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45173       };
45174     } catch (...) {
45175       {
45176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45177       };
45178     }
45179   }
45180
45181   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45182   return jresult;
45183 }
45184
45185
45186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45187   void * jresult ;
45188   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45189   unsigned int arg2 ;
45190   unsigned int arg3 ;
45191   Dali::Pixel::Format arg4 ;
45192   unsigned int arg5 ;
45193   Dali::BufferImage result;
45194
45195   arg1 = jarg1;
45196   arg2 = (unsigned int)jarg2;
45197   arg3 = (unsigned int)jarg3;
45198   arg4 = (Dali::Pixel::Format)jarg4;
45199   arg5 = (unsigned int)jarg5;
45200   {
45201     try {
45202       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45203     } catch (std::out_of_range& e) {
45204       {
45205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45206       };
45207     } catch (std::exception& e) {
45208       {
45209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45210       };
45211     } catch (Dali::DaliException e) {
45212       {
45213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45214       };
45215     } catch (...) {
45216       {
45217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45218       };
45219     }
45220   }
45221
45222   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45223
45224
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45230   void * jresult ;
45231   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45232   unsigned int arg2 ;
45233   unsigned int arg3 ;
45234   Dali::Pixel::Format arg4 ;
45235   Dali::BufferImage result;
45236
45237   arg1 = jarg1;
45238   arg2 = (unsigned int)jarg2;
45239   arg3 = (unsigned int)jarg3;
45240   arg4 = (Dali::Pixel::Format)jarg4;
45241   {
45242     try {
45243       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45244     } catch (std::out_of_range& e) {
45245       {
45246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45247       };
45248     } catch (std::exception& e) {
45249       {
45250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45251       };
45252     } catch (Dali::DaliException e) {
45253       {
45254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45255       };
45256     } catch (...) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45259       };
45260     }
45261   }
45262
45263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45264
45265
45266   return jresult;
45267 }
45268
45269
45270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45271   void * jresult ;
45272   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45273   unsigned int arg2 ;
45274   unsigned int arg3 ;
45275   Dali::BufferImage result;
45276
45277   arg1 = jarg1;
45278   arg2 = (unsigned int)jarg2;
45279   arg3 = (unsigned int)jarg3;
45280   {
45281     try {
45282       result = Dali::BufferImage::New(arg1,arg2,arg3);
45283     } catch (std::out_of_range& e) {
45284       {
45285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45286       };
45287     } catch (std::exception& e) {
45288       {
45289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45290       };
45291     } catch (Dali::DaliException e) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45294       };
45295     } catch (...) {
45296       {
45297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45298       };
45299     }
45300   }
45301
45302   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45303
45304
45305   return jresult;
45306 }
45307
45308
45309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45310   void * jresult ;
45311   Dali::BaseHandle arg1 ;
45312   Dali::BaseHandle *argp1 ;
45313   Dali::BufferImage result;
45314
45315   argp1 = (Dali::BaseHandle *)jarg1;
45316   if (!argp1) {
45317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45318     return 0;
45319   }
45320   arg1 = *argp1;
45321   {
45322     try {
45323       result = Dali::BufferImage::DownCast(arg1);
45324     } catch (std::out_of_range& e) {
45325       {
45326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45327       };
45328     } catch (std::exception& e) {
45329       {
45330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45331       };
45332     } catch (Dali::DaliException e) {
45333       {
45334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45335       };
45336     } catch (...) {
45337       {
45338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45339       };
45340     }
45341   }
45342
45343   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45344   return jresult;
45345 }
45346
45347
45348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45349   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45350
45351   arg1 = (Dali::BufferImage *)jarg1;
45352   {
45353     try {
45354       delete arg1;
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (Dali::DaliException e) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45366       };
45367     } catch (...) {
45368       {
45369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45370       };
45371     }
45372   }
45373
45374 }
45375
45376
45377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45378   void * jresult ;
45379   Dali::BufferImage *arg1 = 0 ;
45380   Dali::BufferImage *result = 0 ;
45381
45382   arg1 = (Dali::BufferImage *)jarg1;
45383   if (!arg1) {
45384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45385     return 0;
45386   }
45387   {
45388     try {
45389       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45390     } catch (std::out_of_range& e) {
45391       {
45392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45393       };
45394     } catch (std::exception& e) {
45395       {
45396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45397       };
45398     } catch (Dali::DaliException e) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45401       };
45402     } catch (...) {
45403       {
45404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45405       };
45406     }
45407   }
45408
45409   jresult = (void *)result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45415   void * jresult ;
45416   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45417   Dali::BufferImage *arg2 = 0 ;
45418   Dali::BufferImage *result = 0 ;
45419
45420   arg1 = (Dali::BufferImage *)jarg1;
45421   arg2 = (Dali::BufferImage *)jarg2;
45422   if (!arg2) {
45423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45424     return 0;
45425   }
45426   {
45427     try {
45428       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45429     } catch (std::out_of_range& e) {
45430       {
45431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45432       };
45433     } catch (std::exception& e) {
45434       {
45435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (Dali::DaliException e) {
45438       {
45439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45454   void * jresult ;
45455   Dali::BufferImage result;
45456
45457   {
45458     try {
45459       result = Dali::BufferImage::WHITE();
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45467       };
45468     } catch (Dali::DaliException e) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45471       };
45472     } catch (...) {
45473       {
45474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45475       };
45476     }
45477   }
45478
45479   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45480   return jresult;
45481 }
45482
45483
45484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45485   void * jresult ;
45486   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45487   Dali::PixelBuffer *result = 0 ;
45488
45489   arg1 = (Dali::BufferImage *)jarg1;
45490   {
45491     try {
45492       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45493     } catch (std::out_of_range& e) {
45494       {
45495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45496       };
45497     } catch (std::exception& e) {
45498       {
45499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45500       };
45501     } catch (Dali::DaliException e) {
45502       {
45503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45504       };
45505     } catch (...) {
45506       {
45507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45508       };
45509     }
45510   }
45511
45512   jresult = (void *)result;
45513   return jresult;
45514 }
45515
45516
45517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45518   unsigned int jresult ;
45519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45520   unsigned int result;
45521
45522   arg1 = (Dali::BufferImage *)jarg1;
45523   {
45524     try {
45525       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45526     } catch (std::out_of_range& e) {
45527       {
45528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45529       };
45530     } catch (std::exception& e) {
45531       {
45532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45533       };
45534     } catch (Dali::DaliException e) {
45535       {
45536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45537       };
45538     } catch (...) {
45539       {
45540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45541       };
45542     }
45543   }
45544
45545   jresult = result;
45546   return jresult;
45547 }
45548
45549
45550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45551   unsigned int jresult ;
45552   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45553   unsigned int result;
45554
45555   arg1 = (Dali::BufferImage *)jarg1;
45556   {
45557     try {
45558       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45559     } catch (std::out_of_range& e) {
45560       {
45561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45562       };
45563     } catch (std::exception& e) {
45564       {
45565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45566       };
45567     } catch (Dali::DaliException e) {
45568       {
45569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45570       };
45571     } catch (...) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45574       };
45575     }
45576   }
45577
45578   jresult = result;
45579   return jresult;
45580 }
45581
45582
45583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45584   int jresult ;
45585   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45586   Dali::Pixel::Format result;
45587
45588   arg1 = (Dali::BufferImage *)jarg1;
45589   {
45590     try {
45591       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45592     } catch (std::out_of_range& e) {
45593       {
45594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45595       };
45596     } catch (std::exception& e) {
45597       {
45598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45599       };
45600     } catch (Dali::DaliException e) {
45601       {
45602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45603       };
45604     } catch (...) {
45605       {
45606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45607       };
45608     }
45609   }
45610
45611   jresult = (int)result;
45612   return jresult;
45613 }
45614
45615
45616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45617   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45618
45619   arg1 = (Dali::BufferImage *)jarg1;
45620   {
45621     try {
45622       (arg1)->Update();
45623     } catch (std::out_of_range& e) {
45624       {
45625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45626       };
45627     } catch (std::exception& e) {
45628       {
45629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45630       };
45631     } catch (Dali::DaliException e) {
45632       {
45633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45634       };
45635     } catch (...) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45638       };
45639     }
45640   }
45641
45642 }
45643
45644
45645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45646   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45647   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45648   Dali::RectArea *argp2 ;
45649
45650   arg1 = (Dali::BufferImage *)jarg1;
45651   argp2 = (Dali::RectArea *)jarg2;
45652   if (!argp2) {
45653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45654     return ;
45655   }
45656   arg2 = *argp2;
45657   {
45658     try {
45659       (arg1)->Update(arg2);
45660     } catch (std::out_of_range& e) {
45661       {
45662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45663       };
45664     } catch (std::exception& e) {
45665       {
45666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45667       };
45668     } catch (Dali::DaliException e) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45675       };
45676     }
45677   }
45678
45679 }
45680
45681
45682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45683   unsigned int jresult ;
45684   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45685   bool result;
45686
45687   arg1 = (Dali::BufferImage *)jarg1;
45688   {
45689     try {
45690       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45691     } catch (std::out_of_range& e) {
45692       {
45693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45694       };
45695     } catch (std::exception& e) {
45696       {
45697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (Dali::DaliException e) {
45700       {
45701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45702       };
45703     } catch (...) {
45704       {
45705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45706       };
45707     }
45708   }
45709
45710   jresult = result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45716   void * jresult ;
45717   Dali::EncodedBufferImage *result = 0 ;
45718
45719   {
45720     try {
45721       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45722     } catch (std::out_of_range& e) {
45723       {
45724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (std::exception& e) {
45727       {
45728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45729       };
45730     } catch (Dali::DaliException e) {
45731       {
45732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45733       };
45734     } catch (...) {
45735       {
45736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45737       };
45738     }
45739   }
45740
45741   jresult = (void *)result;
45742   return jresult;
45743 }
45744
45745
45746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45747   void * jresult ;
45748   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45749   std::size_t arg2 ;
45750   Dali::EncodedBufferImage result;
45751
45752   arg1 = (uint8_t *)jarg1;
45753   arg2 = (std::size_t)jarg2;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (Dali::DaliException e) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45768       };
45769     } catch (...) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45772       };
45773     }
45774   }
45775
45776   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45782   void * jresult ;
45783   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45784   std::size_t arg2 ;
45785   Dali::ImageDimensions arg3 ;
45786   Dali::FittingMode::Type arg4 ;
45787   Dali::SamplingMode::Type arg5 ;
45788   bool arg6 ;
45789   Dali::ImageDimensions *argp3 ;
45790   Dali::EncodedBufferImage result;
45791
45792   arg1 = (uint8_t *)jarg1;
45793   arg2 = (std::size_t)jarg2;
45794   argp3 = (Dali::ImageDimensions *)jarg3;
45795   if (!argp3) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45797     return 0;
45798   }
45799   arg3 = *argp3;
45800   arg4 = (Dali::FittingMode::Type)jarg4;
45801   arg5 = (Dali::SamplingMode::Type)jarg5;
45802   arg6 = jarg6 ? true : false;
45803   {
45804     try {
45805       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45806     } catch (std::out_of_range& e) {
45807       {
45808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (std::exception& e) {
45811       {
45812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45813       };
45814     } catch (Dali::DaliException e) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45821       };
45822     }
45823   }
45824
45825   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45826   return jresult;
45827 }
45828
45829
45830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45831   void * jresult ;
45832   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45833   std::size_t arg2 ;
45834   Dali::ImageDimensions arg3 ;
45835   Dali::FittingMode::Type arg4 ;
45836   Dali::SamplingMode::Type arg5 ;
45837   Dali::ImageDimensions *argp3 ;
45838   Dali::EncodedBufferImage result;
45839
45840   arg1 = (uint8_t *)jarg1;
45841   arg2 = (std::size_t)jarg2;
45842   argp3 = (Dali::ImageDimensions *)jarg3;
45843   if (!argp3) {
45844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45845     return 0;
45846   }
45847   arg3 = *argp3;
45848   arg4 = (Dali::FittingMode::Type)jarg4;
45849   arg5 = (Dali::SamplingMode::Type)jarg5;
45850   {
45851     try {
45852       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (Dali::DaliException e) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45864       };
45865     } catch (...) {
45866       {
45867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45868       };
45869     }
45870   }
45871
45872   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45878   void * jresult ;
45879   Dali::BaseHandle arg1 ;
45880   Dali::BaseHandle *argp1 ;
45881   Dali::EncodedBufferImage result;
45882
45883   argp1 = (Dali::BaseHandle *)jarg1;
45884   if (!argp1) {
45885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45886     return 0;
45887   }
45888   arg1 = *argp1;
45889   {
45890     try {
45891       result = Dali::EncodedBufferImage::DownCast(arg1);
45892     } catch (std::out_of_range& e) {
45893       {
45894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45895       };
45896     } catch (std::exception& e) {
45897       {
45898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45899       };
45900     } catch (Dali::DaliException e) {
45901       {
45902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45903       };
45904     } catch (...) {
45905       {
45906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45907       };
45908     }
45909   }
45910
45911   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45917   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45918
45919   arg1 = (Dali::EncodedBufferImage *)jarg1;
45920   {
45921     try {
45922       delete arg1;
45923     } catch (std::out_of_range& e) {
45924       {
45925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45926       };
45927     } catch (std::exception& e) {
45928       {
45929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45930       };
45931     } catch (Dali::DaliException e) {
45932       {
45933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45934       };
45935     } catch (...) {
45936       {
45937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45938       };
45939     }
45940   }
45941
45942 }
45943
45944
45945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45946   void * jresult ;
45947   Dali::EncodedBufferImage *arg1 = 0 ;
45948   Dali::EncodedBufferImage *result = 0 ;
45949
45950   arg1 = (Dali::EncodedBufferImage *)jarg1;
45951   if (!arg1) {
45952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45953     return 0;
45954   }
45955   {
45956     try {
45957       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45958     } catch (std::out_of_range& e) {
45959       {
45960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (std::exception& e) {
45963       {
45964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45965       };
45966     } catch (Dali::DaliException e) {
45967       {
45968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45969       };
45970     } catch (...) {
45971       {
45972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45973       };
45974     }
45975   }
45976
45977   jresult = (void *)result;
45978   return jresult;
45979 }
45980
45981
45982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45983   void * jresult ;
45984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45985   Dali::EncodedBufferImage *arg2 = 0 ;
45986   Dali::EncodedBufferImage *result = 0 ;
45987
45988   arg1 = (Dali::EncodedBufferImage *)jarg1;
45989   arg2 = (Dali::EncodedBufferImage *)jarg2;
45990   if (!arg2) {
45991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45992     return 0;
45993   }
45994   {
45995     try {
45996       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45997     } catch (std::out_of_range& e) {
45998       {
45999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46000       };
46001     } catch (std::exception& e) {
46002       {
46003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (Dali::DaliException e) {
46006       {
46007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015
46016   jresult = (void *)result;
46017   return jresult;
46018 }
46019
46020
46021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46022   void * jresult ;
46023   Dali::NativeImage *result = 0 ;
46024
46025   {
46026     try {
46027       result = (Dali::NativeImage *)new Dali::NativeImage();
46028     } catch (std::out_of_range& e) {
46029       {
46030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46031       };
46032     } catch (std::exception& e) {
46033       {
46034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46035       };
46036     } catch (Dali::DaliException e) {
46037       {
46038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46039       };
46040     } catch (...) {
46041       {
46042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46043       };
46044     }
46045   }
46046
46047   jresult = (void *)result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46053   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46054
46055   arg1 = (Dali::NativeImage *)jarg1;
46056   {
46057     try {
46058       delete arg1;
46059     } catch (std::out_of_range& e) {
46060       {
46061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46062       };
46063     } catch (std::exception& e) {
46064       {
46065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46066       };
46067     } catch (Dali::DaliException e) {
46068       {
46069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46074       };
46075     }
46076   }
46077
46078 }
46079
46080
46081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46082   void * jresult ;
46083   Dali::NativeImage *arg1 = 0 ;
46084   Dali::NativeImage *result = 0 ;
46085
46086   arg1 = (Dali::NativeImage *)jarg1;
46087   if (!arg1) {
46088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46089     return 0;
46090   }
46091   {
46092     try {
46093       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46094     } catch (std::out_of_range& e) {
46095       {
46096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46097       };
46098     } catch (std::exception& e) {
46099       {
46100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46101       };
46102     } catch (Dali::DaliException e) {
46103       {
46104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46105       };
46106     } catch (...) {
46107       {
46108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46109       };
46110     }
46111   }
46112
46113   jresult = (void *)result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46119   void * jresult ;
46120   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46121   Dali::NativeImage *arg2 = 0 ;
46122   Dali::NativeImage *result = 0 ;
46123
46124   arg1 = (Dali::NativeImage *)jarg1;
46125   arg2 = (Dali::NativeImage *)jarg2;
46126   if (!arg2) {
46127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46128     return 0;
46129   }
46130   {
46131     try {
46132       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46133     } catch (std::out_of_range& e) {
46134       {
46135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46136       };
46137     } catch (std::exception& e) {
46138       {
46139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46140       };
46141     } catch (Dali::DaliException e) {
46142       {
46143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46144       };
46145     } catch (...) {
46146       {
46147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46148       };
46149     }
46150   }
46151
46152   jresult = (void *)result;
46153   return jresult;
46154 }
46155
46156
46157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46158   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46159
46160   arg1 = (Dali::NativeImage *)jarg1;
46161   {
46162     try {
46163       (arg1)->CreateGlTexture();
46164     } catch (std::out_of_range& e) {
46165       {
46166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46167       };
46168     } catch (std::exception& e) {
46169       {
46170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46171       };
46172     } catch (Dali::DaliException e) {
46173       {
46174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46175       };
46176     } catch (...) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46179       };
46180     }
46181   }
46182
46183 }
46184
46185
46186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46187   void * jresult ;
46188   NativeImageInterface *arg1 = 0 ;
46189   Dali::NativeImage result;
46190
46191   arg1 = (NativeImageInterface *)jarg1;
46192   if (!arg1) {
46193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46194     return 0;
46195   }
46196   {
46197     try {
46198       result = Dali::NativeImage::New(*arg1);
46199     } catch (std::out_of_range& e) {
46200       {
46201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46202       };
46203     } catch (std::exception& e) {
46204       {
46205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46206       };
46207     } catch (Dali::DaliException e) {
46208       {
46209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46210       };
46211     } catch (...) {
46212       {
46213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46214       };
46215     }
46216   }
46217
46218   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46219   return jresult;
46220 }
46221
46222
46223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46224   void * jresult ;
46225   Dali::BaseHandle arg1 ;
46226   Dali::BaseHandle *argp1 ;
46227   Dali::NativeImage result;
46228
46229   argp1 = (Dali::BaseHandle *)jarg1;
46230   if (!argp1) {
46231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46232     return 0;
46233   }
46234   arg1 = *argp1;
46235   {
46236     try {
46237       result = Dali::NativeImage::DownCast(arg1);
46238     } catch (std::out_of_range& e) {
46239       {
46240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46241       };
46242     } catch (std::exception& e) {
46243       {
46244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46245       };
46246     } catch (Dali::DaliException e) {
46247       {
46248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46253       };
46254     }
46255   }
46256
46257   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46263   char * jresult ;
46264   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46265   char *result = 0 ;
46266
46267   arg1 = (Dali::NativeImage *)jarg1;
46268   {
46269     try {
46270       result = (char *)(arg1)->GetCustomFragmentPreFix();
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289
46290   jresult = SWIG_csharp_string_callback((const char *)result);
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46296   char * jresult ;
46297   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46298   char *result = 0 ;
46299
46300   arg1 = (Dali::NativeImage *)jarg1;
46301   {
46302     try {
46303       result = (char *)(arg1)->GetCustomSamplerTypename();
46304     } catch (std::out_of_range& e) {
46305       {
46306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46307       };
46308     } catch (std::exception& e) {
46309       {
46310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (Dali::DaliException e) {
46313       {
46314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322
46323   jresult = SWIG_csharp_string_callback((const char *)result);
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46329   unsigned int jresult ;
46330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46331   bool result;
46332
46333   arg1 = (Dali::NativeImageInterface *)jarg1;
46334   {
46335     try {
46336       result = (bool)(arg1)->GlExtensionCreate();
46337     } catch (std::out_of_range& e) {
46338       {
46339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46340       };
46341     } catch (std::exception& e) {
46342       {
46343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46344       };
46345     } catch (Dali::DaliException e) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46348       };
46349     } catch (...) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46352       };
46353     }
46354   }
46355
46356   jresult = result;
46357   return jresult;
46358 }
46359
46360
46361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46363
46364   arg1 = (Dali::NativeImageInterface *)jarg1;
46365   {
46366     try {
46367       (arg1)->GlExtensionDestroy();
46368     } catch (std::out_of_range& e) {
46369       {
46370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46371       };
46372     } catch (std::exception& e) {
46373       {
46374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46375       };
46376     } catch (Dali::DaliException e) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46383       };
46384     }
46385   }
46386
46387 }
46388
46389
46390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46391   unsigned int jresult ;
46392   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46393   unsigned int result;
46394
46395   arg1 = (Dali::NativeImageInterface *)jarg1;
46396   {
46397     try {
46398       result = (unsigned int)(arg1)->TargetTexture();
46399     } catch (std::out_of_range& e) {
46400       {
46401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46402       };
46403     } catch (std::exception& e) {
46404       {
46405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (Dali::DaliException e) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46414       };
46415     }
46416   }
46417
46418   jresult = result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46424   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46425
46426   arg1 = (Dali::NativeImageInterface *)jarg1;
46427   {
46428     try {
46429       (arg1)->PrepareTexture();
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46445       };
46446     }
46447   }
46448
46449 }
46450
46451
46452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46453   unsigned int jresult ;
46454   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46455   unsigned int result;
46456
46457   arg1 = (Dali::NativeImageInterface *)jarg1;
46458   {
46459     try {
46460       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46461     } catch (std::out_of_range& e) {
46462       {
46463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46464       };
46465     } catch (std::exception& e) {
46466       {
46467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46468       };
46469     } catch (Dali::DaliException e) {
46470       {
46471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46472       };
46473     } catch (...) {
46474       {
46475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46476       };
46477     }
46478   }
46479
46480   jresult = result;
46481   return jresult;
46482 }
46483
46484
46485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46486   unsigned int jresult ;
46487   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46488   unsigned int result;
46489
46490   arg1 = (Dali::NativeImageInterface *)jarg1;
46491   {
46492     try {
46493       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46494     } catch (std::out_of_range& e) {
46495       {
46496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46497       };
46498     } catch (std::exception& e) {
46499       {
46500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46501       };
46502     } catch (Dali::DaliException e) {
46503       {
46504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46505       };
46506     } catch (...) {
46507       {
46508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46509       };
46510     }
46511   }
46512
46513   jresult = result;
46514   return jresult;
46515 }
46516
46517
46518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46519   unsigned int jresult ;
46520   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46521   bool result;
46522
46523   arg1 = (Dali::NativeImageInterface *)jarg1;
46524   {
46525     try {
46526       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46527     } catch (std::out_of_range& e) {
46528       {
46529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46530       };
46531     } catch (std::exception& e) {
46532       {
46533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46534       };
46535     } catch (Dali::DaliException e) {
46536       {
46537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46538       };
46539     } catch (...) {
46540       {
46541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46542       };
46543     }
46544   }
46545
46546   jresult = result;
46547   return jresult;
46548 }
46549
46550
46551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46552   void * jresult ;
46553   std::string *arg1 = 0 ;
46554   Dali::ImageDimensions result;
46555
46556   if (!jarg1) {
46557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46558     return 0;
46559   }
46560   std::string arg1_str(jarg1);
46561   arg1 = &arg1_str;
46562   {
46563     try {
46564       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46565     } catch (std::out_of_range& e) {
46566       {
46567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46568       };
46569     } catch (std::exception& e) {
46570       {
46571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46572       };
46573     } catch (Dali::DaliException e) {
46574       {
46575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46576       };
46577     } catch (...) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46580       };
46581     }
46582   }
46583
46584   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46585
46586   //argout typemap for const std::string&
46587
46588   return jresult;
46589 }
46590
46591
46592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46593   void * jresult ;
46594   Dali::ResourceImage *result = 0 ;
46595
46596   {
46597     try {
46598       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46606       };
46607     } catch (Dali::DaliException e) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46614       };
46615     }
46616   }
46617
46618   jresult = (void *)result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46624   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46625
46626   arg1 = (Dali::ResourceImage *)jarg1;
46627   {
46628     try {
46629       delete arg1;
46630     } catch (std::out_of_range& e) {
46631       {
46632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46633       };
46634     } catch (std::exception& e) {
46635       {
46636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46637       };
46638     } catch (Dali::DaliException e) {
46639       {
46640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46645       };
46646     }
46647   }
46648
46649 }
46650
46651
46652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46653   void * jresult ;
46654   Dali::ResourceImage *arg1 = 0 ;
46655   Dali::ResourceImage *result = 0 ;
46656
46657   arg1 = (Dali::ResourceImage *)jarg1;
46658   if (!arg1) {
46659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46660     return 0;
46661   }
46662   {
46663     try {
46664       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46665     } catch (std::out_of_range& e) {
46666       {
46667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46668       };
46669     } catch (std::exception& e) {
46670       {
46671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46672       };
46673     } catch (Dali::DaliException e) {
46674       {
46675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46676       };
46677     } catch (...) {
46678       {
46679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46680       };
46681     }
46682   }
46683
46684   jresult = (void *)result;
46685   return jresult;
46686 }
46687
46688
46689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46690   void * jresult ;
46691   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46692   Dali::ResourceImage *arg2 = 0 ;
46693   Dali::ResourceImage *result = 0 ;
46694
46695   arg1 = (Dali::ResourceImage *)jarg1;
46696   arg2 = (Dali::ResourceImage *)jarg2;
46697   if (!arg2) {
46698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46699     return 0;
46700   }
46701   {
46702     try {
46703       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46704     } catch (std::out_of_range& e) {
46705       {
46706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46707       };
46708     } catch (std::exception& e) {
46709       {
46710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46711       };
46712     } catch (Dali::DaliException e) {
46713       {
46714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46715       };
46716     } catch (...) {
46717       {
46718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46719       };
46720     }
46721   }
46722
46723   jresult = (void *)result;
46724   return jresult;
46725 }
46726
46727
46728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46729   void * jresult ;
46730   std::string *arg1 = 0 ;
46731   bool arg2 ;
46732   Dali::ResourceImage result;
46733
46734   if (!jarg1) {
46735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46736     return 0;
46737   }
46738   std::string arg1_str(jarg1);
46739   arg1 = &arg1_str;
46740   arg2 = jarg2 ? true : false;
46741   {
46742     try {
46743       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46744     } catch (std::out_of_range& e) {
46745       {
46746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46747       };
46748     } catch (std::exception& e) {
46749       {
46750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (Dali::DaliException e) {
46753       {
46754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46755       };
46756     } catch (...) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46759       };
46760     }
46761   }
46762
46763   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46764
46765   //argout typemap for const std::string&
46766
46767   return jresult;
46768 }
46769
46770
46771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46772   void * jresult ;
46773   std::string *arg1 = 0 ;
46774   Dali::ResourceImage result;
46775
46776   if (!jarg1) {
46777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46778     return 0;
46779   }
46780   std::string arg1_str(jarg1);
46781   arg1 = &arg1_str;
46782   {
46783     try {
46784       result = Dali::ResourceImage::New((std::string const &)*arg1);
46785     } catch (std::out_of_range& e) {
46786       {
46787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46788       };
46789     } catch (std::exception& e) {
46790       {
46791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46792       };
46793     } catch (Dali::DaliException e) {
46794       {
46795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46796       };
46797     } catch (...) {
46798       {
46799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46800       };
46801     }
46802   }
46803
46804   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46805
46806   //argout typemap for const std::string&
46807
46808   return jresult;
46809 }
46810
46811
46812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46813   void * jresult ;
46814   std::string *arg1 = 0 ;
46815   Dali::ImageDimensions arg2 ;
46816   Dali::FittingMode::Type arg3 ;
46817   Dali::SamplingMode::Type arg4 ;
46818   bool arg5 ;
46819   Dali::ImageDimensions *argp2 ;
46820   Dali::ResourceImage result;
46821
46822   if (!jarg1) {
46823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46824     return 0;
46825   }
46826   std::string arg1_str(jarg1);
46827   arg1 = &arg1_str;
46828   argp2 = (Dali::ImageDimensions *)jarg2;
46829   if (!argp2) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46831     return 0;
46832   }
46833   arg2 = *argp2;
46834   arg3 = (Dali::FittingMode::Type)jarg3;
46835   arg4 = (Dali::SamplingMode::Type)jarg4;
46836   arg5 = jarg5 ? true : false;
46837   {
46838     try {
46839       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46840     } catch (std::out_of_range& e) {
46841       {
46842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46843       };
46844     } catch (std::exception& e) {
46845       {
46846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46847       };
46848     } catch (Dali::DaliException e) {
46849       {
46850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46851       };
46852     } catch (...) {
46853       {
46854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46855       };
46856     }
46857   }
46858
46859   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46860
46861   //argout typemap for const std::string&
46862
46863   return jresult;
46864 }
46865
46866
46867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46868   void * jresult ;
46869   std::string *arg1 = 0 ;
46870   Dali::ImageDimensions arg2 ;
46871   Dali::FittingMode::Type arg3 ;
46872   Dali::SamplingMode::Type arg4 ;
46873   Dali::ImageDimensions *argp2 ;
46874   Dali::ResourceImage result;
46875
46876   if (!jarg1) {
46877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46878     return 0;
46879   }
46880   std::string arg1_str(jarg1);
46881   arg1 = &arg1_str;
46882   argp2 = (Dali::ImageDimensions *)jarg2;
46883   if (!argp2) {
46884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46885     return 0;
46886   }
46887   arg2 = *argp2;
46888   arg3 = (Dali::FittingMode::Type)jarg3;
46889   arg4 = (Dali::SamplingMode::Type)jarg4;
46890   {
46891     try {
46892       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (Dali::DaliException e) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46904       };
46905     } catch (...) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46908       };
46909     }
46910   }
46911
46912   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46913
46914   //argout typemap for const std::string&
46915
46916   return jresult;
46917 }
46918
46919
46920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46921   void * jresult ;
46922   std::string *arg1 = 0 ;
46923   Dali::ImageDimensions arg2 ;
46924   Dali::FittingMode::Type arg3 ;
46925   Dali::ImageDimensions *argp2 ;
46926   Dali::ResourceImage result;
46927
46928   if (!jarg1) {
46929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46930     return 0;
46931   }
46932   std::string arg1_str(jarg1);
46933   arg1 = &arg1_str;
46934   argp2 = (Dali::ImageDimensions *)jarg2;
46935   if (!argp2) {
46936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46937     return 0;
46938   }
46939   arg2 = *argp2;
46940   arg3 = (Dali::FittingMode::Type)jarg3;
46941   {
46942     try {
46943       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46944     } catch (std::out_of_range& e) {
46945       {
46946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46947       };
46948     } catch (std::exception& e) {
46949       {
46950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46951       };
46952     } catch (Dali::DaliException e) {
46953       {
46954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46955       };
46956     } catch (...) {
46957       {
46958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46959       };
46960     }
46961   }
46962
46963   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46964
46965   //argout typemap for const std::string&
46966
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46972   void * jresult ;
46973   std::string *arg1 = 0 ;
46974   Dali::ImageDimensions arg2 ;
46975   Dali::ImageDimensions *argp2 ;
46976   Dali::ResourceImage result;
46977
46978   if (!jarg1) {
46979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46980     return 0;
46981   }
46982   std::string arg1_str(jarg1);
46983   arg1 = &arg1_str;
46984   argp2 = (Dali::ImageDimensions *)jarg2;
46985   if (!argp2) {
46986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46987     return 0;
46988   }
46989   arg2 = *argp2;
46990   {
46991     try {
46992       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46993     } catch (std::out_of_range& e) {
46994       {
46995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (std::exception& e) {
46998       {
46999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47000       };
47001     } catch (Dali::DaliException e) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47004       };
47005     } catch (...) {
47006       {
47007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47008       };
47009     }
47010   }
47011
47012   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47013
47014   //argout typemap for const std::string&
47015
47016   return jresult;
47017 }
47018
47019
47020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47021   void * jresult ;
47022   Dali::BaseHandle arg1 ;
47023   Dali::BaseHandle *argp1 ;
47024   Dali::ResourceImage result;
47025
47026   argp1 = (Dali::BaseHandle *)jarg1;
47027   if (!argp1) {
47028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47029     return 0;
47030   }
47031   arg1 = *argp1;
47032   {
47033     try {
47034       result = Dali::ResourceImage::DownCast(arg1);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (Dali::DaliException e) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47046       };
47047     } catch (...) {
47048       {
47049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47050       };
47051     }
47052   }
47053
47054   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47055   return jresult;
47056 }
47057
47058
47059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47060   int jresult ;
47061   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47062   Dali::LoadingState result;
47063
47064   arg1 = (Dali::ResourceImage *)jarg1;
47065   {
47066     try {
47067       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47068     } catch (std::out_of_range& e) {
47069       {
47070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47071       };
47072     } catch (std::exception& e) {
47073       {
47074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (Dali::DaliException e) {
47077       {
47078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47079       };
47080     } catch (...) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47083       };
47084     }
47085   }
47086
47087   jresult = (int)result;
47088   return jresult;
47089 }
47090
47091
47092 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47093   char * jresult ;
47094   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47095   std::string result;
47096
47097   arg1 = (Dali::ResourceImage *)jarg1;
47098   {
47099     try {
47100       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47101     } catch (std::out_of_range& e) {
47102       {
47103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (std::exception& e) {
47106       {
47107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (Dali::DaliException e) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47112       };
47113     } catch (...) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47116       };
47117     }
47118   }
47119
47120   jresult = SWIG_csharp_string_callback((&result)->c_str());
47121   return jresult;
47122 }
47123
47124
47125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47126   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47127
47128   arg1 = (Dali::ResourceImage *)jarg1;
47129   {
47130     try {
47131       (arg1)->Reload();
47132     } catch (std::out_of_range& e) {
47133       {
47134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47135       };
47136     } catch (std::exception& e) {
47137       {
47138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47139       };
47140     } catch (Dali::DaliException e) {
47141       {
47142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47143       };
47144     } catch (...) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47147       };
47148     }
47149   }
47150
47151 }
47152
47153
47154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47155   void * jresult ;
47156   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47157   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47158
47159   arg1 = (Dali::ResourceImage *)jarg1;
47160   {
47161     try {
47162       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47163     } catch (std::out_of_range& e) {
47164       {
47165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47166       };
47167     } catch (std::exception& e) {
47168       {
47169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47170       };
47171     } catch (Dali::DaliException e) {
47172       {
47173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47174       };
47175     } catch (...) {
47176       {
47177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47178       };
47179     }
47180   }
47181
47182   jresult = (void *)result;
47183   return jresult;
47184 }
47185
47186
47187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47188   void * jresult ;
47189   Dali::FrameBufferImage *result = 0 ;
47190
47191   {
47192     try {
47193       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47194     } catch (std::out_of_range& e) {
47195       {
47196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47197       };
47198     } catch (std::exception& e) {
47199       {
47200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47201       };
47202     } catch (Dali::DaliException e) {
47203       {
47204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47205       };
47206     } catch (...) {
47207       {
47208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47209       };
47210     }
47211   }
47212
47213   jresult = (void *)result;
47214   return jresult;
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47219   void * jresult ;
47220   unsigned int arg1 ;
47221   unsigned int arg2 ;
47222   Dali::Pixel::Format arg3 ;
47223   Dali::RenderBuffer::Format arg4 ;
47224   Dali::FrameBufferImage result;
47225
47226   arg1 = (unsigned int)jarg1;
47227   arg2 = (unsigned int)jarg2;
47228   arg3 = (Dali::Pixel::Format)jarg3;
47229   arg4 = (Dali::RenderBuffer::Format)jarg4;
47230   {
47231     try {
47232       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47233     } catch (std::out_of_range& e) {
47234       {
47235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47236       };
47237     } catch (std::exception& e) {
47238       {
47239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47240       };
47241     } catch (Dali::DaliException e) {
47242       {
47243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47244       };
47245     } catch (...) {
47246       {
47247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47248       };
47249     }
47250   }
47251
47252   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47258   void * jresult ;
47259   unsigned int arg1 ;
47260   unsigned int arg2 ;
47261   Dali::Pixel::Format arg3 ;
47262   Dali::FrameBufferImage result;
47263
47264   arg1 = (unsigned int)jarg1;
47265   arg2 = (unsigned int)jarg2;
47266   arg3 = (Dali::Pixel::Format)jarg3;
47267   {
47268     try {
47269       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47270     } catch (std::out_of_range& e) {
47271       {
47272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (std::exception& e) {
47275       {
47276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47277       };
47278     } catch (Dali::DaliException e) {
47279       {
47280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47281       };
47282     } catch (...) {
47283       {
47284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47285       };
47286     }
47287   }
47288
47289   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47290   return jresult;
47291 }
47292
47293
47294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47295   void * jresult ;
47296   unsigned int arg1 ;
47297   unsigned int arg2 ;
47298   Dali::FrameBufferImage result;
47299
47300   arg1 = (unsigned int)jarg1;
47301   arg2 = (unsigned int)jarg2;
47302   {
47303     try {
47304       result = Dali::FrameBufferImage::New(arg1,arg2);
47305     } catch (std::out_of_range& e) {
47306       {
47307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47308       };
47309     } catch (std::exception& e) {
47310       {
47311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (Dali::DaliException e) {
47314       {
47315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47316       };
47317     } catch (...) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47320       };
47321     }
47322   }
47323
47324   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47325   return jresult;
47326 }
47327
47328
47329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47330   void * jresult ;
47331   unsigned int arg1 ;
47332   Dali::FrameBufferImage result;
47333
47334   arg1 = (unsigned int)jarg1;
47335   {
47336     try {
47337       result = Dali::FrameBufferImage::New(arg1);
47338     } catch (std::out_of_range& e) {
47339       {
47340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47341       };
47342     } catch (std::exception& e) {
47343       {
47344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47345       };
47346     } catch (Dali::DaliException e) {
47347       {
47348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47349       };
47350     } catch (...) {
47351       {
47352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47353       };
47354     }
47355   }
47356
47357   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47358   return jresult;
47359 }
47360
47361
47362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47363   void * jresult ;
47364   Dali::FrameBufferImage result;
47365
47366   {
47367     try {
47368       result = Dali::FrameBufferImage::New();
47369     } catch (std::out_of_range& e) {
47370       {
47371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47372       };
47373     } catch (std::exception& e) {
47374       {
47375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47376       };
47377     } catch (Dali::DaliException e) {
47378       {
47379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47380       };
47381     } catch (...) {
47382       {
47383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47384       };
47385     }
47386   }
47387
47388   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47389   return jresult;
47390 }
47391
47392
47393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47394   void * jresult ;
47395   Dali::NativeImageInterface *arg1 = 0 ;
47396   Dali::FrameBufferImage result;
47397
47398   arg1 = (Dali::NativeImageInterface *)jarg1;
47399   if (!arg1) {
47400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47401     return 0;
47402   }
47403   {
47404     try {
47405       result = Dali::FrameBufferImage::New(*arg1);
47406     } catch (std::out_of_range& e) {
47407       {
47408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47409       };
47410     } catch (std::exception& e) {
47411       {
47412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47413       };
47414     } catch (Dali::DaliException e) {
47415       {
47416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47417       };
47418     } catch (...) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47421       };
47422     }
47423   }
47424
47425   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47426   return jresult;
47427 }
47428
47429
47430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47431   void * jresult ;
47432   Dali::BaseHandle arg1 ;
47433   Dali::BaseHandle *argp1 ;
47434   Dali::FrameBufferImage result;
47435
47436   argp1 = (Dali::BaseHandle *)jarg1;
47437   if (!argp1) {
47438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47439     return 0;
47440   }
47441   arg1 = *argp1;
47442   {
47443     try {
47444       result = Dali::FrameBufferImage::DownCast(arg1);
47445     } catch (std::out_of_range& e) {
47446       {
47447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47448       };
47449     } catch (std::exception& e) {
47450       {
47451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47452       };
47453     } catch (Dali::DaliException e) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47456       };
47457     } catch (...) {
47458       {
47459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47460       };
47461     }
47462   }
47463
47464   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47465   return jresult;
47466 }
47467
47468
47469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47470   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47471
47472   arg1 = (Dali::FrameBufferImage *)jarg1;
47473   {
47474     try {
47475       delete arg1;
47476     } catch (std::out_of_range& e) {
47477       {
47478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47479       };
47480     } catch (std::exception& e) {
47481       {
47482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47483       };
47484     } catch (Dali::DaliException e) {
47485       {
47486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47487       };
47488     } catch (...) {
47489       {
47490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47491       };
47492     }
47493   }
47494
47495 }
47496
47497
47498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47499   void * jresult ;
47500   Dali::FrameBufferImage *arg1 = 0 ;
47501   Dali::FrameBufferImage *result = 0 ;
47502
47503   arg1 = (Dali::FrameBufferImage *)jarg1;
47504   if (!arg1) {
47505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47506     return 0;
47507   }
47508   {
47509     try {
47510       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47511     } catch (std::out_of_range& e) {
47512       {
47513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47514       };
47515     } catch (std::exception& e) {
47516       {
47517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47518       };
47519     } catch (Dali::DaliException e) {
47520       {
47521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47522       };
47523     } catch (...) {
47524       {
47525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47526       };
47527     }
47528   }
47529
47530   jresult = (void *)result;
47531   return jresult;
47532 }
47533
47534
47535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47536   void * jresult ;
47537   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47538   Dali::FrameBufferImage *arg2 = 0 ;
47539   Dali::FrameBufferImage *result = 0 ;
47540
47541   arg1 = (Dali::FrameBufferImage *)jarg1;
47542   arg2 = (Dali::FrameBufferImage *)jarg2;
47543   if (!arg2) {
47544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47545     return 0;
47546   }
47547   {
47548     try {
47549       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47550     } catch (std::out_of_range& e) {
47551       {
47552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47553       };
47554     } catch (std::exception& e) {
47555       {
47556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47557       };
47558     } catch (Dali::DaliException e) {
47559       {
47560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47561       };
47562     } catch (...) {
47563       {
47564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47565       };
47566     }
47567   }
47568
47569   jresult = (void *)result;
47570   return jresult;
47571 }
47572
47573
47574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47575   void * jresult ;
47576   Dali::NinePatchImage *result = 0 ;
47577
47578   {
47579     try {
47580       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47581     } catch (std::out_of_range& e) {
47582       {
47583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47584       };
47585     } catch (std::exception& e) {
47586       {
47587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47588       };
47589     } catch (Dali::DaliException e) {
47590       {
47591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47592       };
47593     } catch (...) {
47594       {
47595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47596       };
47597     }
47598   }
47599
47600   jresult = (void *)result;
47601   return jresult;
47602 }
47603
47604
47605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47606   void * jresult ;
47607   std::string *arg1 = 0 ;
47608   Dali::NinePatchImage result;
47609
47610   if (!jarg1) {
47611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47612     return 0;
47613   }
47614   std::string arg1_str(jarg1);
47615   arg1 = &arg1_str;
47616   {
47617     try {
47618       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47619     } catch (std::out_of_range& e) {
47620       {
47621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47622       };
47623     } catch (std::exception& e) {
47624       {
47625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (Dali::DaliException e) {
47628       {
47629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47630       };
47631     } catch (...) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47634       };
47635     }
47636   }
47637
47638   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47639
47640   //argout typemap for const std::string&
47641
47642   return jresult;
47643 }
47644
47645
47646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47647   void * jresult ;
47648   Dali::BaseHandle arg1 ;
47649   Dali::BaseHandle *argp1 ;
47650   Dali::NinePatchImage result;
47651
47652   argp1 = (Dali::BaseHandle *)jarg1;
47653   if (!argp1) {
47654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47655     return 0;
47656   }
47657   arg1 = *argp1;
47658   {
47659     try {
47660       result = Dali::NinePatchImage::DownCast(arg1);
47661     } catch (std::out_of_range& e) {
47662       {
47663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47664       };
47665     } catch (std::exception& e) {
47666       {
47667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (Dali::DaliException e) {
47670       {
47671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47676       };
47677     }
47678   }
47679
47680   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47681   return jresult;
47682 }
47683
47684
47685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47686   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47687
47688   arg1 = (Dali::NinePatchImage *)jarg1;
47689   {
47690     try {
47691       delete arg1;
47692     } catch (std::out_of_range& e) {
47693       {
47694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47695       };
47696     } catch (std::exception& e) {
47697       {
47698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47699       };
47700     } catch (Dali::DaliException e) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47707       };
47708     }
47709   }
47710
47711 }
47712
47713
47714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47715   void * jresult ;
47716   Dali::NinePatchImage *arg1 = 0 ;
47717   Dali::NinePatchImage *result = 0 ;
47718
47719   arg1 = (Dali::NinePatchImage *)jarg1;
47720   if (!arg1) {
47721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47722     return 0;
47723   }
47724   {
47725     try {
47726       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47727     } catch (std::out_of_range& e) {
47728       {
47729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (std::exception& e) {
47732       {
47733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47734       };
47735     } catch (Dali::DaliException e) {
47736       {
47737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47738       };
47739     } catch (...) {
47740       {
47741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47742       };
47743     }
47744   }
47745
47746   jresult = (void *)result;
47747   return jresult;
47748 }
47749
47750
47751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47752   void * jresult ;
47753   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47754   Dali::NinePatchImage *arg2 = 0 ;
47755   Dali::NinePatchImage *result = 0 ;
47756
47757   arg1 = (Dali::NinePatchImage *)jarg1;
47758   arg2 = (Dali::NinePatchImage *)jarg2;
47759   if (!arg2) {
47760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47761     return 0;
47762   }
47763   {
47764     try {
47765       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47766     } catch (std::out_of_range& e) {
47767       {
47768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47769       };
47770     } catch (std::exception& e) {
47771       {
47772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47773       };
47774     } catch (Dali::DaliException e) {
47775       {
47776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47777       };
47778     } catch (...) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47781       };
47782     }
47783   }
47784
47785   jresult = (void *)result;
47786   return jresult;
47787 }
47788
47789
47790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47791   void * jresult ;
47792   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47793   Dali::Vector4 result;
47794
47795   arg1 = (Dali::NinePatchImage *)jarg1;
47796   {
47797     try {
47798       result = (arg1)->GetStretchBorders();
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47806       };
47807     } catch (Dali::DaliException e) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47810       };
47811     } catch (...) {
47812       {
47813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47814       };
47815     }
47816   }
47817
47818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47819   return jresult;
47820 }
47821
47822
47823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47824   void * jresult ;
47825   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47826   Dali::NinePatchImage::StretchRanges *result = 0 ;
47827
47828   arg1 = (Dali::NinePatchImage *)jarg1;
47829   {
47830     try {
47831       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47832     } catch (std::out_of_range& e) {
47833       {
47834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47835       };
47836     } catch (std::exception& e) {
47837       {
47838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47839       };
47840     } catch (Dali::DaliException e) {
47841       {
47842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47843       };
47844     } catch (...) {
47845       {
47846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47847       };
47848     }
47849   }
47850
47851   jresult = (void *)result;
47852   return jresult;
47853 }
47854
47855
47856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47857   void * jresult ;
47858   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47859   Dali::NinePatchImage::StretchRanges *result = 0 ;
47860
47861   arg1 = (Dali::NinePatchImage *)jarg1;
47862   {
47863     try {
47864       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47865     } catch (std::out_of_range& e) {
47866       {
47867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47868       };
47869     } catch (std::exception& e) {
47870       {
47871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (Dali::DaliException e) {
47874       {
47875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883
47884   jresult = (void *)result;
47885   return jresult;
47886 }
47887
47888
47889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47890   void * jresult ;
47891   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47892   Dali::Rect< int > result;
47893
47894   arg1 = (Dali::NinePatchImage *)jarg1;
47895   {
47896     try {
47897       result = (arg1)->GetChildRectangle();
47898     } catch (std::out_of_range& e) {
47899       {
47900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47901       };
47902     } catch (std::exception& e) {
47903       {
47904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47905       };
47906     } catch (Dali::DaliException e) {
47907       {
47908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47913       };
47914     }
47915   }
47916
47917   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47918   return jresult;
47919 }
47920
47921
47922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47923   void * jresult ;
47924   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47925   Dali::BufferImage result;
47926
47927   arg1 = (Dali::NinePatchImage *)jarg1;
47928   {
47929     try {
47930       result = (arg1)->CreateCroppedBufferImage();
47931     } catch (std::out_of_range& e) {
47932       {
47933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47934       };
47935     } catch (std::exception& e) {
47936       {
47937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47938       };
47939     } catch (Dali::DaliException e) {
47940       {
47941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47942       };
47943     } catch (...) {
47944       {
47945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47946       };
47947     }
47948   }
47949
47950   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47951   return jresult;
47952 }
47953
47954
47955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47956   unsigned int jresult ;
47957   std::string *arg1 = 0 ;
47958   bool result;
47959
47960   if (!jarg1) {
47961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47962     return 0;
47963   }
47964   std::string arg1_str(jarg1);
47965   arg1 = &arg1_str;
47966   {
47967     try {
47968       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47969     } catch (std::out_of_range& e) {
47970       {
47971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47972       };
47973     } catch (std::exception& e) {
47974       {
47975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47976       };
47977     } catch (Dali::DaliException e) {
47978       {
47979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47980       };
47981     } catch (...) {
47982       {
47983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47984       };
47985     }
47986   }
47987
47988   jresult = result;
47989
47990   //argout typemap for const std::string&
47991
47992   return jresult;
47993 }
47994
47995
47996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47997   int jresult ;
47998   int result;
47999
48000   result = (int)Dali::CameraActor::Property::TYPE;
48001   jresult = (int)result;
48002   return jresult;
48003 }
48004
48005
48006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48007   int jresult ;
48008   int result;
48009
48010   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48011   jresult = (int)result;
48012   return jresult;
48013 }
48014
48015
48016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48017   int jresult ;
48018   int result;
48019
48020   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48021   jresult = (int)result;
48022   return jresult;
48023 }
48024
48025
48026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48027   int jresult ;
48028   int result;
48029
48030   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48031   jresult = (int)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48037   int jresult ;
48038   int result;
48039
48040   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48041   jresult = (int)result;
48042   return jresult;
48043 }
48044
48045
48046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48047   int jresult ;
48048   int result;
48049
48050   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48051   jresult = (int)result;
48052   return jresult;
48053 }
48054
48055
48056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48057   int jresult ;
48058   int result;
48059
48060   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48061   jresult = (int)result;
48062   return jresult;
48063 }
48064
48065
48066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48067   int jresult ;
48068   int result;
48069
48070   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48071   jresult = (int)result;
48072   return jresult;
48073 }
48074
48075
48076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48077   int jresult ;
48078   int result;
48079
48080   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48081   jresult = (int)result;
48082   return jresult;
48083 }
48084
48085
48086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48087   int jresult ;
48088   int result;
48089
48090   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48091   jresult = (int)result;
48092   return jresult;
48093 }
48094
48095
48096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48097   int jresult ;
48098   int result;
48099
48100   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48101   jresult = (int)result;
48102   return jresult;
48103 }
48104
48105
48106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48107   int jresult ;
48108   int result;
48109
48110   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48111   jresult = (int)result;
48112   return jresult;
48113 }
48114
48115
48116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48117   int jresult ;
48118   int result;
48119
48120   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48121   jresult = (int)result;
48122   return jresult;
48123 }
48124
48125
48126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48127   int jresult ;
48128   int result;
48129
48130   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48131   jresult = (int)result;
48132   return jresult;
48133 }
48134
48135
48136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48137   void * jresult ;
48138   Dali::CameraActor::Property *result = 0 ;
48139
48140   {
48141     try {
48142       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (Dali::DaliException e) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48158       };
48159     }
48160   }
48161
48162   jresult = (void *)result;
48163   return jresult;
48164 }
48165
48166
48167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48168   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48169
48170   arg1 = (Dali::CameraActor::Property *)jarg1;
48171   {
48172     try {
48173       delete arg1;
48174     } catch (std::out_of_range& e) {
48175       {
48176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48177       };
48178     } catch (std::exception& e) {
48179       {
48180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48181       };
48182     } catch (Dali::DaliException e) {
48183       {
48184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48185       };
48186     } catch (...) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48189       };
48190     }
48191   }
48192
48193 }
48194
48195
48196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48197   void * jresult ;
48198   Dali::CameraActor *result = 0 ;
48199
48200   {
48201     try {
48202       result = (Dali::CameraActor *)new Dali::CameraActor();
48203     } catch (std::out_of_range& e) {
48204       {
48205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48206       };
48207     } catch (std::exception& e) {
48208       {
48209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48210       };
48211     } catch (Dali::DaliException e) {
48212       {
48213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48214       };
48215     } catch (...) {
48216       {
48217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48218       };
48219     }
48220   }
48221
48222   jresult = (void *)result;
48223   return jresult;
48224 }
48225
48226
48227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48228   void * jresult ;
48229   Dali::CameraActor result;
48230
48231   {
48232     try {
48233       result = Dali::CameraActor::New();
48234     } catch (std::out_of_range& e) {
48235       {
48236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48237       };
48238     } catch (std::exception& e) {
48239       {
48240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48241       };
48242     } catch (Dali::DaliException e) {
48243       {
48244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48245       };
48246     } catch (...) {
48247       {
48248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48249       };
48250     }
48251   }
48252
48253   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48254   return jresult;
48255 }
48256
48257
48258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48259   void * jresult ;
48260   Dali::Size *arg1 = 0 ;
48261   Dali::CameraActor result;
48262
48263   arg1 = (Dali::Size *)jarg1;
48264   if (!arg1) {
48265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48266     return 0;
48267   }
48268   {
48269     try {
48270       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48271     } catch (std::out_of_range& e) {
48272       {
48273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48274       };
48275     } catch (std::exception& e) {
48276       {
48277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (Dali::DaliException e) {
48280       {
48281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48282       };
48283     } catch (...) {
48284       {
48285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48286       };
48287     }
48288   }
48289
48290   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48291   return jresult;
48292 }
48293
48294
48295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48296   void * jresult ;
48297   Dali::BaseHandle arg1 ;
48298   Dali::BaseHandle *argp1 ;
48299   Dali::CameraActor result;
48300
48301   argp1 = (Dali::BaseHandle *)jarg1;
48302   if (!argp1) {
48303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48304     return 0;
48305   }
48306   arg1 = *argp1;
48307   {
48308     try {
48309       result = Dali::CameraActor::DownCast(arg1);
48310     } catch (std::out_of_range& e) {
48311       {
48312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48313       };
48314     } catch (std::exception& e) {
48315       {
48316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48317       };
48318     } catch (Dali::DaliException e) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48321       };
48322     } catch (...) {
48323       {
48324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48325       };
48326     }
48327   }
48328
48329   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48336
48337   arg1 = (Dali::CameraActor *)jarg1;
48338   {
48339     try {
48340       delete arg1;
48341     } catch (std::out_of_range& e) {
48342       {
48343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48344       };
48345     } catch (std::exception& e) {
48346       {
48347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48348       };
48349     } catch (Dali::DaliException e) {
48350       {
48351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48352       };
48353     } catch (...) {
48354       {
48355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48356       };
48357     }
48358   }
48359
48360 }
48361
48362
48363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48364   void * jresult ;
48365   Dali::CameraActor *arg1 = 0 ;
48366   Dali::CameraActor *result = 0 ;
48367
48368   arg1 = (Dali::CameraActor *)jarg1;
48369   if (!arg1) {
48370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48371     return 0;
48372   }
48373   {
48374     try {
48375       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48376     } catch (std::out_of_range& e) {
48377       {
48378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48379       };
48380     } catch (std::exception& e) {
48381       {
48382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48383       };
48384     } catch (Dali::DaliException e) {
48385       {
48386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48387       };
48388     } catch (...) {
48389       {
48390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48391       };
48392     }
48393   }
48394
48395   jresult = (void *)result;
48396   return jresult;
48397 }
48398
48399
48400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48401   void * jresult ;
48402   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48403   Dali::CameraActor *arg2 = 0 ;
48404   Dali::CameraActor *result = 0 ;
48405
48406   arg1 = (Dali::CameraActor *)jarg1;
48407   arg2 = (Dali::CameraActor *)jarg2;
48408   if (!arg2) {
48409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48410     return 0;
48411   }
48412   {
48413     try {
48414       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48415     } catch (std::out_of_range& e) {
48416       {
48417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48418       };
48419     } catch (std::exception& e) {
48420       {
48421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48422       };
48423     } catch (Dali::DaliException e) {
48424       {
48425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48430       };
48431     }
48432   }
48433
48434   jresult = (void *)result;
48435   return jresult;
48436 }
48437
48438
48439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48441   Dali::Camera::Type arg2 ;
48442
48443   arg1 = (Dali::CameraActor *)jarg1;
48444   arg2 = (Dali::Camera::Type)jarg2;
48445   {
48446     try {
48447       (arg1)->SetType(arg2);
48448     } catch (std::out_of_range& e) {
48449       {
48450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48451       };
48452     } catch (std::exception& e) {
48453       {
48454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48455       };
48456     } catch (Dali::DaliException e) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48459       };
48460     } catch (...) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48463       };
48464     }
48465   }
48466
48467 }
48468
48469
48470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48471   int jresult ;
48472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48473   Dali::Camera::Type result;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   {
48477     try {
48478       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48479     } catch (std::out_of_range& e) {
48480       {
48481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48482       };
48483     } catch (std::exception& e) {
48484       {
48485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48486       };
48487     } catch (Dali::DaliException e) {
48488       {
48489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48490       };
48491     } catch (...) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48494       };
48495     }
48496   }
48497
48498   jresult = (int)result;
48499   return jresult;
48500 }
48501
48502
48503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48504   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48505   Dali::Camera::ProjectionMode arg2 ;
48506
48507   arg1 = (Dali::CameraActor *)jarg1;
48508   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48509   {
48510     try {
48511       (arg1)->SetProjectionMode(arg2);
48512     } catch (std::out_of_range& e) {
48513       {
48514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48515       };
48516     } catch (std::exception& e) {
48517       {
48518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48519       };
48520     } catch (Dali::DaliException e) {
48521       {
48522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48523       };
48524     } catch (...) {
48525       {
48526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48527       };
48528     }
48529   }
48530
48531 }
48532
48533
48534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48535   int jresult ;
48536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48537   Dali::Camera::ProjectionMode result;
48538
48539   arg1 = (Dali::CameraActor *)jarg1;
48540   {
48541     try {
48542       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48550       };
48551     } catch (Dali::DaliException e) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48554       };
48555     } catch (...) {
48556       {
48557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48558       };
48559     }
48560   }
48561
48562   jresult = (int)result;
48563   return jresult;
48564 }
48565
48566
48567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48568   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48569   float arg2 ;
48570
48571   arg1 = (Dali::CameraActor *)jarg1;
48572   arg2 = (float)jarg2;
48573   {
48574     try {
48575       (arg1)->SetFieldOfView(arg2);
48576     } catch (std::out_of_range& e) {
48577       {
48578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48579       };
48580     } catch (std::exception& e) {
48581       {
48582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48583       };
48584     } catch (Dali::DaliException e) {
48585       {
48586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48591       };
48592     }
48593   }
48594
48595 }
48596
48597
48598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48599   float jresult ;
48600   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48601   float result;
48602
48603   arg1 = (Dali::CameraActor *)jarg1;
48604   {
48605     try {
48606       result = (float)(arg1)->GetFieldOfView();
48607     } catch (std::out_of_range& e) {
48608       {
48609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48610       };
48611     } catch (std::exception& e) {
48612       {
48613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48614       };
48615     } catch (Dali::DaliException e) {
48616       {
48617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48618       };
48619     } catch (...) {
48620       {
48621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48622       };
48623     }
48624   }
48625
48626   jresult = result;
48627   return jresult;
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48632   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48633   float arg2 ;
48634
48635   arg1 = (Dali::CameraActor *)jarg1;
48636   arg2 = (float)jarg2;
48637   {
48638     try {
48639       (arg1)->SetAspectRatio(arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (Dali::DaliException e) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658
48659 }
48660
48661
48662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48663   float jresult ;
48664   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48665   float result;
48666
48667   arg1 = (Dali::CameraActor *)jarg1;
48668   {
48669     try {
48670       result = (float)(arg1)->GetAspectRatio();
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48678       };
48679     } catch (Dali::DaliException e) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48686       };
48687     }
48688   }
48689
48690   jresult = result;
48691   return jresult;
48692 }
48693
48694
48695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48696   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48697   float arg2 ;
48698
48699   arg1 = (Dali::CameraActor *)jarg1;
48700   arg2 = (float)jarg2;
48701   {
48702     try {
48703       (arg1)->SetNearClippingPlane(arg2);
48704     } catch (std::out_of_range& e) {
48705       {
48706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48707       };
48708     } catch (std::exception& e) {
48709       {
48710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48711       };
48712     } catch (Dali::DaliException e) {
48713       {
48714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48715       };
48716     } catch (...) {
48717       {
48718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48719       };
48720     }
48721   }
48722
48723 }
48724
48725
48726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48727   float jresult ;
48728   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48729   float result;
48730
48731   arg1 = (Dali::CameraActor *)jarg1;
48732   {
48733     try {
48734       result = (float)(arg1)->GetNearClippingPlane();
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48742       };
48743     } catch (Dali::DaliException e) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48746       };
48747     } catch (...) {
48748       {
48749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48750       };
48751     }
48752   }
48753
48754   jresult = result;
48755   return jresult;
48756 }
48757
48758
48759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48760   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48761   float arg2 ;
48762
48763   arg1 = (Dali::CameraActor *)jarg1;
48764   arg2 = (float)jarg2;
48765   {
48766     try {
48767       (arg1)->SetFarClippingPlane(arg2);
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (Dali::DaliException e) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48779       };
48780     } catch (...) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48783       };
48784     }
48785   }
48786
48787 }
48788
48789
48790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48791   float jresult ;
48792   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48793   float result;
48794
48795   arg1 = (Dali::CameraActor *)jarg1;
48796   {
48797     try {
48798       result = (float)(arg1)->GetFarClippingPlane();
48799     } catch (std::out_of_range& e) {
48800       {
48801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48802       };
48803     } catch (std::exception& e) {
48804       {
48805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (Dali::DaliException e) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48810       };
48811     } catch (...) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48814       };
48815     }
48816   }
48817
48818   jresult = result;
48819   return jresult;
48820 }
48821
48822
48823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48824   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48825   Dali::Vector3 *arg2 = 0 ;
48826
48827   arg1 = (Dali::CameraActor *)jarg1;
48828   arg2 = (Dali::Vector3 *)jarg2;
48829   if (!arg2) {
48830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48831     return ;
48832   }
48833   {
48834     try {
48835       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48836     } catch (std::out_of_range& e) {
48837       {
48838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48839       };
48840     } catch (std::exception& e) {
48841       {
48842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48843       };
48844     } catch (Dali::DaliException e) {
48845       {
48846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48847       };
48848     } catch (...) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48851       };
48852     }
48853   }
48854
48855 }
48856
48857
48858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48859   void * jresult ;
48860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48861   Dali::Vector3 result;
48862
48863   arg1 = (Dali::CameraActor *)jarg1;
48864   {
48865     try {
48866       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48867     } catch (std::out_of_range& e) {
48868       {
48869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48870       };
48871     } catch (std::exception& e) {
48872       {
48873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48874       };
48875     } catch (Dali::DaliException e) {
48876       {
48877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48878       };
48879     } catch (...) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48882       };
48883     }
48884   }
48885
48886   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48887   return jresult;
48888 }
48889
48890
48891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48892   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48893   bool arg2 ;
48894
48895   arg1 = (Dali::CameraActor *)jarg1;
48896   arg2 = jarg2 ? true : false;
48897   {
48898     try {
48899       (arg1)->SetInvertYAxis(arg2);
48900     } catch (std::out_of_range& e) {
48901       {
48902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48903       };
48904     } catch (std::exception& e) {
48905       {
48906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (Dali::DaliException e) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918
48919 }
48920
48921
48922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48923   unsigned int jresult ;
48924   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48925   bool result;
48926
48927   arg1 = (Dali::CameraActor *)jarg1;
48928   {
48929     try {
48930       result = (bool)(arg1)->GetInvertYAxis();
48931     } catch (std::out_of_range& e) {
48932       {
48933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48934       };
48935     } catch (std::exception& e) {
48936       {
48937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48938       };
48939     } catch (Dali::DaliException e) {
48940       {
48941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48942       };
48943     } catch (...) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48946       };
48947     }
48948   }
48949
48950   jresult = result;
48951   return jresult;
48952 }
48953
48954
48955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48956   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48957   Dali::Size *arg2 = 0 ;
48958
48959   arg1 = (Dali::CameraActor *)jarg1;
48960   arg2 = (Dali::Size *)jarg2;
48961   if (!arg2) {
48962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48963     return ;
48964   }
48965   {
48966     try {
48967       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48968     } catch (std::out_of_range& e) {
48969       {
48970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48971       };
48972     } catch (std::exception& e) {
48973       {
48974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48975       };
48976     } catch (Dali::DaliException e) {
48977       {
48978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48979       };
48980     } catch (...) {
48981       {
48982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48983       };
48984     }
48985   }
48986
48987 }
48988
48989
48990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48991   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48992   Dali::Size *arg2 = 0 ;
48993
48994   arg1 = (Dali::CameraActor *)jarg1;
48995   arg2 = (Dali::Size *)jarg2;
48996   if (!arg2) {
48997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48998     return ;
48999   }
49000   {
49001     try {
49002       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
49003     } catch (std::out_of_range& e) {
49004       {
49005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49006       };
49007     } catch (std::exception& e) {
49008       {
49009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49010       };
49011     } catch (Dali::DaliException e) {
49012       {
49013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49014       };
49015     } catch (...) {
49016       {
49017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49018       };
49019     }
49020   }
49021
49022 }
49023
49024
49025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49027   float arg2 ;
49028   float arg3 ;
49029   float arg4 ;
49030   float arg5 ;
49031   float arg6 ;
49032   float arg7 ;
49033
49034   arg1 = (Dali::CameraActor *)jarg1;
49035   arg2 = (float)jarg2;
49036   arg3 = (float)jarg3;
49037   arg4 = (float)jarg4;
49038   arg5 = (float)jarg5;
49039   arg6 = (float)jarg6;
49040   arg7 = (float)jarg7;
49041   {
49042     try {
49043       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49044     } catch (std::out_of_range& e) {
49045       {
49046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (std::exception& e) {
49049       {
49050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49051       };
49052     } catch (Dali::DaliException e) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49055       };
49056     } catch (...) {
49057       {
49058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49059       };
49060     }
49061   }
49062
49063 }
49064
49065
49066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49067   void * jresult ;
49068   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49069
49070   {
49071     try {
49072       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49080       };
49081     } catch (Dali::DaliException e) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49084       };
49085     } catch (...) {
49086       {
49087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49088       };
49089     }
49090   }
49091
49092   jresult = (void *)result;
49093   return jresult;
49094 }
49095
49096
49097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49098   void * jresult ;
49099   std::string arg1 ;
49100   Dali::Property::Value arg2 ;
49101   Dali::Property::Value *argp2 ;
49102   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49103
49104   if (!jarg1) {
49105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49106     return 0;
49107   }
49108   (&arg1)->assign(jarg1);
49109   argp2 = (Dali::Property::Value *)jarg2;
49110   if (!argp2) {
49111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49112     return 0;
49113   }
49114   arg2 = *argp2;
49115   {
49116     try {
49117       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49118     } catch (std::out_of_range& e) {
49119       {
49120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49121       };
49122     } catch (std::exception& e) {
49123       {
49124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49125       };
49126     } catch (Dali::DaliException e) {
49127       {
49128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49129       };
49130     } catch (...) {
49131       {
49132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49133       };
49134     }
49135   }
49136
49137   jresult = (void *)result;
49138   return jresult;
49139 }
49140
49141
49142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49143   void * jresult ;
49144   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49145   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49146
49147   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49148   if (!arg1) {
49149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49150     return 0;
49151   }
49152   {
49153     try {
49154       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);
49155     } catch (std::out_of_range& e) {
49156       {
49157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49158       };
49159     } catch (std::exception& e) {
49160       {
49161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49162       };
49163     } catch (Dali::DaliException e) {
49164       {
49165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49166       };
49167     } catch (...) {
49168       {
49169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49170       };
49171     }
49172   }
49173
49174   jresult = (void *)result;
49175   return jresult;
49176 }
49177
49178
49179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49180   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49181   std::string *arg2 = 0 ;
49182
49183   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49184   if (!jarg2) {
49185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49186     return ;
49187   }
49188   std::string arg2_str(jarg2);
49189   arg2 = &arg2_str;
49190   if (arg1) (arg1)->first = *arg2;
49191
49192   //argout typemap for const std::string&
49193
49194 }
49195
49196
49197 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49198   char * jresult ;
49199   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49200   std::string *result = 0 ;
49201
49202   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49203   result = (std::string *) & ((arg1)->first);
49204   jresult = SWIG_csharp_string_callback(result->c_str());
49205   return jresult;
49206 }
49207
49208
49209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49210   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49211   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49212
49213   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49214   arg2 = (Dali::Property::Value *)jarg2;
49215   if (arg1) (arg1)->second = *arg2;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49220   void * jresult ;
49221   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49222   Dali::Property::Value *result = 0 ;
49223
49224   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49225   result = (Dali::Property::Value *)& ((arg1)->second);
49226   jresult = (void *)result;
49227   return jresult;
49228 }
49229
49230
49231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49232   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49233
49234   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49235   {
49236     try {
49237       delete arg1;
49238     } catch (std::out_of_range& e) {
49239       {
49240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49241       };
49242     } catch (std::exception& e) {
49243       {
49244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49245       };
49246     } catch (Dali::DaliException e) {
49247       {
49248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49249       };
49250     } catch (...) {
49251       {
49252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49253       };
49254     }
49255   }
49256
49257 }
49258
49259
49260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49262
49263   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49264   {
49265     try {
49266       (arg1)->clear();
49267     } catch (std::out_of_range& e) {
49268       {
49269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49270       };
49271     } catch (std::exception& e) {
49272       {
49273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49274       };
49275     } catch (Dali::DaliException e) {
49276       {
49277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49278       };
49279     } catch (...) {
49280       {
49281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49282       };
49283     }
49284   }
49285
49286 }
49287
49288
49289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49290   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49291   Dali::TouchPoint *arg2 = 0 ;
49292
49293   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49294   arg2 = (Dali::TouchPoint *)jarg2;
49295   if (!arg2) {
49296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49297     return ;
49298   }
49299   {
49300     try {
49301       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (Dali::DaliException e) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320
49321 }
49322
49323
49324 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49325   unsigned long jresult ;
49326   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49327   std::vector< Dali::TouchPoint >::size_type result;
49328
49329   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49330   {
49331     try {
49332       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49333     } catch (std::out_of_range& e) {
49334       {
49335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49336       };
49337     } catch (std::exception& e) {
49338       {
49339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (Dali::DaliException e) {
49342       {
49343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49344       };
49345     } catch (...) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49348       };
49349     }
49350   }
49351
49352   jresult = (unsigned long)result;
49353   return jresult;
49354 }
49355
49356
49357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49358   unsigned long jresult ;
49359   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49360   std::vector< Dali::TouchPoint >::size_type result;
49361
49362   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49363   {
49364     try {
49365       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49366     } catch (std::out_of_range& e) {
49367       {
49368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49369       };
49370     } catch (std::exception& e) {
49371       {
49372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (Dali::DaliException e) {
49375       {
49376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49381       };
49382     }
49383   }
49384
49385   jresult = (unsigned long)result;
49386   return jresult;
49387 }
49388
49389
49390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49391   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49392   std::vector< Dali::TouchPoint >::size_type arg2 ;
49393
49394   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49395   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49396   {
49397     try {
49398       (arg1)->reserve(arg2);
49399     } catch (std::out_of_range& e) {
49400       {
49401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49402       };
49403     } catch (std::exception& e) {
49404       {
49405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49406       };
49407     } catch (Dali::DaliException e) {
49408       {
49409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49410       };
49411     } catch (...) {
49412       {
49413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49414       };
49415     }
49416   }
49417
49418 }
49419
49420
49421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49422   void * jresult ;
49423   std::vector< Dali::TouchPoint > *result = 0 ;
49424
49425   {
49426     try {
49427       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49428     } catch (std::out_of_range& e) {
49429       {
49430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49431       };
49432     } catch (std::exception& e) {
49433       {
49434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49435       };
49436     } catch (Dali::DaliException e) {
49437       {
49438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49439       };
49440     } catch (...) {
49441       {
49442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49443       };
49444     }
49445   }
49446
49447   jresult = (void *)result;
49448   return jresult;
49449 }
49450
49451
49452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49453   void * jresult ;
49454   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49455   std::vector< Dali::TouchPoint > *result = 0 ;
49456
49457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49458   if (!arg1) {
49459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49460     return 0;
49461   }
49462   {
49463     try {
49464       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49465     } catch (std::out_of_range& e) {
49466       {
49467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49468       };
49469     } catch (std::exception& e) {
49470       {
49471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (Dali::DaliException e) {
49474       {
49475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49476       };
49477     } catch (...) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49480       };
49481     }
49482   }
49483
49484   jresult = (void *)result;
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49490   void * jresult ;
49491   int arg1 ;
49492   std::vector< Dali::TouchPoint > *result = 0 ;
49493
49494   arg1 = (int)jarg1;
49495   {
49496     try {
49497       try {
49498         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49499       }
49500       catch(std::out_of_range &_e) {
49501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49502         return 0;
49503       }
49504
49505     } catch (std::out_of_range& e) {
49506       {
49507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (std::exception& e) {
49510       {
49511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49512       };
49513     } catch (Dali::DaliException e) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49516       };
49517     } catch (...) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49520       };
49521     }
49522   }
49523
49524   jresult = (void *)result;
49525   return jresult;
49526 }
49527
49528
49529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49530   void * jresult ;
49531   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49532   int arg2 ;
49533   SwigValueWrapper< Dali::TouchPoint > result;
49534
49535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49536   arg2 = (int)jarg2;
49537   {
49538     try {
49539       try {
49540         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49541       }
49542       catch(std::out_of_range &_e) {
49543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49544         return 0;
49545       }
49546
49547     } catch (std::out_of_range& e) {
49548       {
49549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (std::exception& e) {
49552       {
49553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49554       };
49555     } catch (Dali::DaliException e) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49558       };
49559     } catch (...) {
49560       {
49561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49562       };
49563     }
49564   }
49565
49566   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49567   return jresult;
49568 }
49569
49570
49571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49572   void * jresult ;
49573   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49574   int arg2 ;
49575   Dali::TouchPoint *result = 0 ;
49576
49577   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49578   arg2 = (int)jarg2;
49579   {
49580     try {
49581       try {
49582         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49583       }
49584       catch(std::out_of_range &_e) {
49585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49586         return 0;
49587       }
49588
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49596       };
49597     } catch (Dali::DaliException e) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49600       };
49601     } catch (...) {
49602       {
49603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49604       };
49605     }
49606   }
49607
49608   jresult = (void *)result;
49609   return jresult;
49610 }
49611
49612
49613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49614   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49615   int arg2 ;
49616   Dali::TouchPoint *arg3 = 0 ;
49617
49618   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49619   arg2 = (int)jarg2;
49620   arg3 = (Dali::TouchPoint *)jarg3;
49621   if (!arg3) {
49622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49623     return ;
49624   }
49625   {
49626     try {
49627       try {
49628         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49629       }
49630       catch(std::out_of_range &_e) {
49631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49632         return ;
49633       }
49634
49635     } catch (std::out_of_range& e) {
49636       {
49637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49638       };
49639     } catch (std::exception& e) {
49640       {
49641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (Dali::DaliException e) {
49644       {
49645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49646       };
49647     } catch (...) {
49648       {
49649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49650       };
49651     }
49652   }
49653
49654 }
49655
49656
49657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49658   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49659   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49660
49661   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49662   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49663   if (!arg2) {
49664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49665     return ;
49666   }
49667   {
49668     try {
49669       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688
49689 }
49690
49691
49692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49693   void * jresult ;
49694   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49695   int arg2 ;
49696   int arg3 ;
49697   std::vector< Dali::TouchPoint > *result = 0 ;
49698
49699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49700   arg2 = (int)jarg2;
49701   arg3 = (int)jarg3;
49702   {
49703     try {
49704       try {
49705         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49706       }
49707       catch(std::out_of_range &_e) {
49708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49709         return 0;
49710       }
49711       catch(std::invalid_argument &_e) {
49712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49713         return 0;
49714       }
49715
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49731       };
49732     }
49733   }
49734
49735   jresult = (void *)result;
49736   return jresult;
49737 }
49738
49739
49740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49741   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49742   int arg2 ;
49743   Dali::TouchPoint *arg3 = 0 ;
49744
49745   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49746   arg2 = (int)jarg2;
49747   arg3 = (Dali::TouchPoint *)jarg3;
49748   if (!arg3) {
49749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49750     return ;
49751   }
49752   {
49753     try {
49754       try {
49755         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49756       }
49757       catch(std::out_of_range &_e) {
49758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49759         return ;
49760       }
49761
49762     } catch (std::out_of_range& e) {
49763       {
49764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49765       };
49766     } catch (std::exception& e) {
49767       {
49768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49769       };
49770     } catch (Dali::DaliException e) {
49771       {
49772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49773       };
49774     } catch (...) {
49775       {
49776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49777       };
49778     }
49779   }
49780
49781 }
49782
49783
49784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49785   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49786   int arg2 ;
49787   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49788
49789   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49790   arg2 = (int)jarg2;
49791   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49792   if (!arg3) {
49793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49794     return ;
49795   }
49796   {
49797     try {
49798       try {
49799         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49800       }
49801       catch(std::out_of_range &_e) {
49802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49803         return ;
49804       }
49805
49806     } catch (std::out_of_range& e) {
49807       {
49808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49809       };
49810     } catch (std::exception& e) {
49811       {
49812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49813       };
49814     } catch (Dali::DaliException e) {
49815       {
49816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49817       };
49818     } catch (...) {
49819       {
49820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49821       };
49822     }
49823   }
49824
49825 }
49826
49827
49828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49829   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49830   int arg2 ;
49831
49832   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49833   arg2 = (int)jarg2;
49834   {
49835     try {
49836       try {
49837         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49838       }
49839       catch(std::out_of_range &_e) {
49840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49841         return ;
49842       }
49843
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49851       };
49852     } catch (Dali::DaliException e) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49855       };
49856     } catch (...) {
49857       {
49858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49859       };
49860     }
49861   }
49862
49863 }
49864
49865
49866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49867   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49868   int arg2 ;
49869   int arg3 ;
49870
49871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49872   arg2 = (int)jarg2;
49873   arg3 = (int)jarg3;
49874   {
49875     try {
49876       try {
49877         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49878       }
49879       catch(std::out_of_range &_e) {
49880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49881         return ;
49882       }
49883       catch(std::invalid_argument &_e) {
49884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49885         return ;
49886       }
49887
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49895       };
49896     } catch (Dali::DaliException e) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49899       };
49900     } catch (...) {
49901       {
49902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49903       };
49904     }
49905   }
49906
49907 }
49908
49909
49910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49911   void * jresult ;
49912   Dali::TouchPoint *arg1 = 0 ;
49913   int arg2 ;
49914   std::vector< Dali::TouchPoint > *result = 0 ;
49915
49916   arg1 = (Dali::TouchPoint *)jarg1;
49917   if (!arg1) {
49918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49919     return 0;
49920   }
49921   arg2 = (int)jarg2;
49922   {
49923     try {
49924       try {
49925         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49926       }
49927       catch(std::out_of_range &_e) {
49928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49929         return 0;
49930       }
49931
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49939       };
49940     } catch (Dali::DaliException e) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49943       };
49944     } catch (...) {
49945       {
49946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49947       };
49948     }
49949   }
49950
49951   jresult = (void *)result;
49952   return jresult;
49953 }
49954
49955
49956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49958
49959   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49960   {
49961     try {
49962       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49963     } catch (std::out_of_range& e) {
49964       {
49965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (std::exception& e) {
49968       {
49969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (Dali::DaliException e) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49978       };
49979     }
49980   }
49981
49982 }
49983
49984
49985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49986   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49987   int arg2 ;
49988   int arg3 ;
49989
49990   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49991   arg2 = (int)jarg2;
49992   arg3 = (int)jarg3;
49993   {
49994     try {
49995       try {
49996         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49997       }
49998       catch(std::out_of_range &_e) {
49999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50000         return ;
50001       }
50002       catch(std::invalid_argument &_e) {
50003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
50004         return ;
50005       }
50006
50007     } catch (std::out_of_range& e) {
50008       {
50009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50010       };
50011     } catch (std::exception& e) {
50012       {
50013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50014       };
50015     } catch (Dali::DaliException e) {
50016       {
50017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50018       };
50019     } catch (...) {
50020       {
50021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50022       };
50023     }
50024   }
50025
50026 }
50027
50028
50029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50030   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50031   int arg2 ;
50032   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50033
50034   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50035   arg2 = (int)jarg2;
50036   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50037   if (!arg3) {
50038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50039     return ;
50040   }
50041   {
50042     try {
50043       try {
50044         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50045       }
50046       catch(std::out_of_range &_e) {
50047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50048         return ;
50049       }
50050
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50058       };
50059     } catch (Dali::DaliException e) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50062       };
50063     } catch (...) {
50064       {
50065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50066       };
50067     }
50068   }
50069
50070 }
50071
50072
50073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50074   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50075
50076   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50077   {
50078     try {
50079       delete arg1;
50080     } catch (std::out_of_range& e) {
50081       {
50082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50083       };
50084     } catch (std::exception& e) {
50085       {
50086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50087       };
50088     } catch (Dali::DaliException e) {
50089       {
50090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50095       };
50096     }
50097   }
50098
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50103   void * jresult ;
50104   Dali::Rect< int > *result = 0 ;
50105
50106   {
50107     try {
50108       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50109     } catch (std::out_of_range& e) {
50110       {
50111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50112       };
50113     } catch (std::exception& e) {
50114       {
50115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50116       };
50117     } catch (Dali::DaliException e) {
50118       {
50119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50120       };
50121     } catch (...) {
50122       {
50123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50124       };
50125     }
50126   }
50127
50128   jresult = (void *)result;
50129   return jresult;
50130 }
50131
50132
50133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50134   void * jresult ;
50135   int arg1 ;
50136   int arg2 ;
50137   int arg3 ;
50138   int arg4 ;
50139   Dali::Rect< int > *result = 0 ;
50140
50141   arg1 = (int)jarg1;
50142   arg2 = (int)jarg2;
50143   arg3 = (int)jarg3;
50144   arg4 = (int)jarg4;
50145   {
50146     try {
50147       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50148     } catch (std::out_of_range& e) {
50149       {
50150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50151       };
50152     } catch (std::exception& e) {
50153       {
50154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50155       };
50156     } catch (Dali::DaliException e) {
50157       {
50158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50159       };
50160     } catch (...) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50163       };
50164     }
50165   }
50166
50167   jresult = (void *)result;
50168   return jresult;
50169 }
50170
50171
50172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50173   void * jresult ;
50174   Dali::Rect< int > *arg1 = 0 ;
50175   Dali::Rect< int > *result = 0 ;
50176
50177   arg1 = (Dali::Rect< int > *)jarg1;
50178   if (!arg1) {
50179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50180     return 0;
50181   }
50182   {
50183     try {
50184       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50185     } catch (std::out_of_range& e) {
50186       {
50187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50188       };
50189     } catch (std::exception& e) {
50190       {
50191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (Dali::DaliException e) {
50194       {
50195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50196       };
50197     } catch (...) {
50198       {
50199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50200       };
50201     }
50202   }
50203
50204   jresult = (void *)result;
50205   return jresult;
50206 }
50207
50208
50209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50210   void * jresult ;
50211   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50212   Dali::Rect< int > *arg2 = 0 ;
50213   Dali::Rect< int > *result = 0 ;
50214
50215   arg1 = (Dali::Rect< int > *)jarg1;
50216   arg2 = (Dali::Rect< int > *)jarg2;
50217   if (!arg2) {
50218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50219     return 0;
50220   }
50221   {
50222     try {
50223       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50224     } catch (std::out_of_range& e) {
50225       {
50226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50227       };
50228     } catch (std::exception& e) {
50229       {
50230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50231       };
50232     } catch (Dali::DaliException e) {
50233       {
50234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50235       };
50236     } catch (...) {
50237       {
50238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50239       };
50240     }
50241   }
50242
50243   jresult = (void *)result;
50244   return jresult;
50245 }
50246
50247
50248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50249   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50250   int arg2 ;
50251   int arg3 ;
50252   int arg4 ;
50253   int arg5 ;
50254
50255   arg1 = (Dali::Rect< int > *)jarg1;
50256   arg2 = (int)jarg2;
50257   arg3 = (int)jarg3;
50258   arg4 = (int)jarg4;
50259   arg5 = (int)jarg5;
50260   {
50261     try {
50262       (arg1)->Set(arg2,arg3,arg4,arg5);
50263     } catch (std::out_of_range& e) {
50264       {
50265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50266       };
50267     } catch (std::exception& e) {
50268       {
50269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50270       };
50271     } catch (Dali::DaliException e) {
50272       {
50273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50274       };
50275     } catch (...) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50278       };
50279     }
50280   }
50281
50282 }
50283
50284
50285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50286   unsigned int jresult ;
50287   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50288   bool result;
50289
50290   arg1 = (Dali::Rect< int > *)jarg1;
50291   {
50292     try {
50293       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50294     } catch (std::out_of_range& e) {
50295       {
50296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50297       };
50298     } catch (std::exception& e) {
50299       {
50300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50301       };
50302     } catch (Dali::DaliException e) {
50303       {
50304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50305       };
50306     } catch (...) {
50307       {
50308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50309       };
50310     }
50311   }
50312
50313   jresult = result;
50314   return jresult;
50315 }
50316
50317
50318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50319   int jresult ;
50320   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50321   int result;
50322
50323   arg1 = (Dali::Rect< int > *)jarg1;
50324   {
50325     try {
50326       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50327     } catch (std::out_of_range& e) {
50328       {
50329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50330       };
50331     } catch (std::exception& e) {
50332       {
50333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50334       };
50335     } catch (Dali::DaliException e) {
50336       {
50337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50338       };
50339     } catch (...) {
50340       {
50341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50342       };
50343     }
50344   }
50345
50346   jresult = result;
50347   return jresult;
50348 }
50349
50350
50351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50352   int jresult ;
50353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50354   int result;
50355
50356   arg1 = (Dali::Rect< int > *)jarg1;
50357   {
50358     try {
50359       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50360     } catch (std::out_of_range& e) {
50361       {
50362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50363       };
50364     } catch (std::exception& e) {
50365       {
50366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50367       };
50368     } catch (Dali::DaliException e) {
50369       {
50370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50371       };
50372     } catch (...) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50375       };
50376     }
50377   }
50378
50379   jresult = result;
50380   return jresult;
50381 }
50382
50383
50384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50385   int jresult ;
50386   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50387   int result;
50388
50389   arg1 = (Dali::Rect< int > *)jarg1;
50390   {
50391     try {
50392       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (Dali::DaliException e) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50404       };
50405     } catch (...) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50408       };
50409     }
50410   }
50411
50412   jresult = result;
50413   return jresult;
50414 }
50415
50416
50417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50418   int jresult ;
50419   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50420   int result;
50421
50422   arg1 = (Dali::Rect< int > *)jarg1;
50423   {
50424     try {
50425       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50426     } catch (std::out_of_range& e) {
50427       {
50428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50429       };
50430     } catch (std::exception& e) {
50431       {
50432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50433       };
50434     } catch (Dali::DaliException e) {
50435       {
50436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50437       };
50438     } catch (...) {
50439       {
50440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50441       };
50442     }
50443   }
50444
50445   jresult = result;
50446   return jresult;
50447 }
50448
50449
50450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50451   int jresult ;
50452   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50453   int result;
50454
50455   arg1 = (Dali::Rect< int > *)jarg1;
50456   {
50457     try {
50458       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50459     } catch (std::out_of_range& e) {
50460       {
50461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50462       };
50463     } catch (std::exception& e) {
50464       {
50465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50466       };
50467     } catch (Dali::DaliException e) {
50468       {
50469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50470       };
50471     } catch (...) {
50472       {
50473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50474       };
50475     }
50476   }
50477
50478   jresult = result;
50479   return jresult;
50480 }
50481
50482
50483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50484   unsigned int jresult ;
50485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50486   Dali::Rect< int > *arg2 = 0 ;
50487   bool result;
50488
50489   arg1 = (Dali::Rect< int > *)jarg1;
50490   arg2 = (Dali::Rect< int > *)jarg2;
50491   if (!arg2) {
50492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50493     return 0;
50494   }
50495   {
50496     try {
50497       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50498     } catch (std::out_of_range& e) {
50499       {
50500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50501       };
50502     } catch (std::exception& e) {
50503       {
50504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50505       };
50506     } catch (Dali::DaliException e) {
50507       {
50508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50509       };
50510     } catch (...) {
50511       {
50512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50513       };
50514     }
50515   }
50516
50517   jresult = result;
50518   return jresult;
50519 }
50520
50521
50522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50523   unsigned int jresult ;
50524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50525   Dali::Rect< int > *arg2 = 0 ;
50526   bool result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   arg2 = (Dali::Rect< int > *)jarg2;
50530   if (!arg2) {
50531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50532     return 0;
50533   }
50534   {
50535     try {
50536       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50537     } catch (std::out_of_range& e) {
50538       {
50539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50540       };
50541     } catch (std::exception& e) {
50542       {
50543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (Dali::DaliException e) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555
50556   jresult = result;
50557   return jresult;
50558 }
50559
50560
50561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int arg2 ;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   arg2 = (int)jarg2;
50567   if (arg1) (arg1)->x = arg2;
50568 }
50569
50570
50571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50572   int jresult ;
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int result;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   result = (int) ((arg1)->x);
50578   jresult = result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int arg2 ;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   arg2 = (int)jarg2;
50589   if (arg1) (arg1)->left = arg2;
50590 }
50591
50592
50593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50594   int jresult ;
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int result;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   result = (int) ((arg1)->left);
50600   jresult = result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int arg2 ;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   arg2 = (int)jarg2;
50611   if (arg1) (arg1)->y = arg2;
50612 }
50613
50614
50615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50616   int jresult ;
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618   int result;
50619
50620   arg1 = (Dali::Rect< int > *)jarg1;
50621   result = (int) ((arg1)->y);
50622   jresult = result;
50623   return jresult;
50624 }
50625
50626
50627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50628   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50629   int arg2 ;
50630
50631   arg1 = (Dali::Rect< int > *)jarg1;
50632   arg2 = (int)jarg2;
50633   if (arg1) (arg1)->right = arg2;
50634 }
50635
50636
50637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50638   int jresult ;
50639   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50640   int result;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   result = (int) ((arg1)->right);
50644   jresult = result;
50645   return jresult;
50646 }
50647
50648
50649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50650   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50651   int arg2 ;
50652
50653   arg1 = (Dali::Rect< int > *)jarg1;
50654   arg2 = (int)jarg2;
50655   if (arg1) (arg1)->width = arg2;
50656 }
50657
50658
50659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50660   int jresult ;
50661   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50662   int result;
50663
50664   arg1 = (Dali::Rect< int > *)jarg1;
50665   result = (int) ((arg1)->width);
50666   jresult = result;
50667   return jresult;
50668 }
50669
50670
50671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50672   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50673   int arg2 ;
50674
50675   arg1 = (Dali::Rect< int > *)jarg1;
50676   arg2 = (int)jarg2;
50677   if (arg1) (arg1)->bottom = arg2;
50678 }
50679
50680
50681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50682   int jresult ;
50683   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50684   int result;
50685
50686   arg1 = (Dali::Rect< int > *)jarg1;
50687   result = (int) ((arg1)->bottom);
50688   jresult = result;
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50694   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50695   int arg2 ;
50696
50697   arg1 = (Dali::Rect< int > *)jarg1;
50698   arg2 = (int)jarg2;
50699   if (arg1) (arg1)->height = arg2;
50700 }
50701
50702
50703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50704   int jresult ;
50705   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50706   int result;
50707
50708   arg1 = (Dali::Rect< int > *)jarg1;
50709   result = (int) ((arg1)->height);
50710   jresult = result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50716   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50717   int arg2 ;
50718
50719   arg1 = (Dali::Rect< int > *)jarg1;
50720   arg2 = (int)jarg2;
50721   if (arg1) (arg1)->top = arg2;
50722 }
50723
50724
50725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50726   int jresult ;
50727   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50728   int result;
50729
50730   arg1 = (Dali::Rect< int > *)jarg1;
50731   result = (int) ((arg1)->top);
50732   jresult = result;
50733   return jresult;
50734 }
50735
50736
50737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50738   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50739
50740   arg1 = (Dali::Rect< int > *)jarg1;
50741   {
50742     try {
50743       delete arg1;
50744     } catch (std::out_of_range& e) {
50745       {
50746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50747       };
50748     } catch (std::exception& e) {
50749       {
50750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50751       };
50752     } catch (Dali::DaliException e) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50755       };
50756     } catch (...) {
50757       {
50758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50759       };
50760     }
50761   }
50762
50763 }
50764
50765
50766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50767   void * jresult ;
50768   Dali::Rect< float > *result = 0 ;
50769
50770   {
50771     try {
50772       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50773     } catch (std::out_of_range& e) {
50774       {
50775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50776       };
50777     } catch (std::exception& e) {
50778       {
50779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50780       };
50781     } catch (Dali::DaliException e) {
50782       {
50783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50784       };
50785     } catch (...) {
50786       {
50787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50788       };
50789     }
50790   }
50791
50792   jresult = (void *)result;
50793   return jresult;
50794 }
50795
50796
50797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50798   void * jresult ;
50799   float arg1 ;
50800   float arg2 ;
50801   float arg3 ;
50802   float arg4 ;
50803   Dali::Rect< float > *result = 0 ;
50804
50805   arg1 = (float)jarg1;
50806   arg2 = (float)jarg2;
50807   arg3 = (float)jarg4;
50808   arg4 = (float)jarg3;
50809   {
50810     try {
50811       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50812     } catch (std::out_of_range& e) {
50813       {
50814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50815       };
50816     } catch (std::exception& e) {
50817       {
50818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50819       };
50820     } catch (Dali::DaliException e) {
50821       {
50822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50823       };
50824     } catch (...) {
50825       {
50826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50827       };
50828     }
50829   }
50830
50831   jresult = (void *)result;
50832   return jresult;
50833 }
50834
50835
50836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50837   void * jresult ;
50838   Dali::Rect< float > *arg1 = 0 ;
50839   Dali::Rect< float > *result = 0 ;
50840
50841   arg1 = (Dali::Rect< float > *)jarg1;
50842   if (!arg1) {
50843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50844     return 0;
50845   }
50846   {
50847     try {
50848       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50849     } catch (std::out_of_range& e) {
50850       {
50851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50852       };
50853     } catch (std::exception& e) {
50854       {
50855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50856       };
50857     } catch (Dali::DaliException e) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50860       };
50861     } catch (...) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50864       };
50865     }
50866   }
50867
50868   jresult = (void *)result;
50869   return jresult;
50870 }
50871
50872
50873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50874   void * jresult ;
50875   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50876   Dali::Rect< float > *arg2 = 0 ;
50877   Dali::Rect< float > *result = 0 ;
50878
50879   arg1 = (Dali::Rect< float > *)jarg1;
50880   arg2 = (Dali::Rect< float > *)jarg2;
50881   if (!arg2) {
50882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50883     return 0;
50884   }
50885   {
50886     try {
50887       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50888     } catch (std::out_of_range& e) {
50889       {
50890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50891       };
50892     } catch (std::exception& e) {
50893       {
50894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50895       };
50896     } catch (Dali::DaliException e) {
50897       {
50898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50899       };
50900     } catch (...) {
50901       {
50902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50903       };
50904     }
50905   }
50906
50907   jresult = (void *)result;
50908   return jresult;
50909 }
50910
50911
50912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50913   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50914   float arg2 ;
50915   float arg3 ;
50916   float arg4 ;
50917   float arg5 ;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   arg2 = (float)jarg2;
50921   arg3 = (float)jarg3;
50922   arg4 = (float)jarg5;
50923   arg5 = (float)jarg4;
50924   {
50925     try {
50926       (arg1)->Set(arg2,arg3,arg4,arg5);
50927     } catch (std::out_of_range& e) {
50928       {
50929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50930       };
50931     } catch (std::exception& e) {
50932       {
50933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50934       };
50935     } catch (Dali::DaliException e) {
50936       {
50937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50938       };
50939     } catch (...) {
50940       {
50941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50942       };
50943     }
50944   }
50945
50946 }
50947
50948
50949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float arg2 ;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   arg2 = (float)jarg2;
50955   if (arg1) (arg1)->left = arg2;
50956 }
50957
50958
50959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50960   float jresult ;
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962   float result;
50963
50964   arg1 = (Dali::Rect< float > *)jarg1;
50965   result = (float) ((arg1)->left);
50966   jresult = result;
50967   return jresult;
50968 }
50969
50970
50971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50972   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50973   float arg2 ;
50974
50975   arg1 = (Dali::Rect< float > *)jarg1;
50976   arg2 = (float)jarg2;
50977   if (arg1) (arg1)->left = arg2;
50978 }
50979
50980
50981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50982   float jresult ;
50983   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50984   float result;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   result = (float) ((arg1)->left);
50988   jresult = result;
50989   return jresult;
50990 }
50991
50992
50993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50994   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50995   float arg2 ;
50996
50997   arg1 = (Dali::Rect< float > *)jarg1;
50998   arg2 = (float)jarg2;
50999   if (arg1) (arg1)->right = arg2;
51000 }
51001
51002
51003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
51004   float jresult ;
51005   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51006   float result;
51007
51008   arg1 = (Dali::Rect< float > *)jarg1;
51009   result = (float) ((arg1)->right);
51010   jresult = result;
51011   return jresult;
51012 }
51013
51014
51015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51016   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51017   float arg2 ;
51018
51019   arg1 = (Dali::Rect< float > *)jarg1;
51020   arg2 = (float)jarg2;
51021   if (arg1) (arg1)->right = arg2;
51022 }
51023
51024
51025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51026   float jresult ;
51027   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51028   float result;
51029
51030   arg1 = (Dali::Rect< float > *)jarg1;
51031   result = (float) ((arg1)->right);
51032   jresult = result;
51033   return jresult;
51034 }
51035
51036
51037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51038   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51039   float arg2 ;
51040
51041   arg1 = (Dali::Rect< float > *)jarg1;
51042   arg2 = (float)jarg2;
51043   if (arg1) (arg1)->bottom = arg2;
51044 }
51045
51046
51047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51048   float jresult ;
51049   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51050   float result;
51051
51052   arg1 = (Dali::Rect< float > *)jarg1;
51053   result = (float) ((arg1)->bottom);
51054   jresult = result;
51055   return jresult;
51056 }
51057
51058
51059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51060   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51061   float arg2 ;
51062
51063   arg1 = (Dali::Rect< float > *)jarg1;
51064   arg2 = (float)jarg2;
51065   if (arg1) (arg1)->top = arg2;
51066 }
51067
51068
51069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51070   float jresult ;
51071   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51072   float result;
51073
51074   arg1 = (Dali::Rect< float > *)jarg1;
51075   result = (float) ((arg1)->top);
51076   jresult = result;
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51082   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51083
51084   arg1 = (Dali::Rect< float > *)jarg1;
51085   {
51086     try {
51087       delete arg1;
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (Dali::DaliException e) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51099       };
51100     } catch (...) {
51101       {
51102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51103       };
51104     }
51105   }
51106
51107 }
51108
51109
51110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51111   int jresult ;
51112   int result;
51113
51114   result = (int)Dali::Vector< int >::BaseType;
51115   jresult = (int)result;
51116   return jresult;
51117 }
51118
51119
51120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51121   void * jresult ;
51122   Dali::Vector< int > *result = 0 ;
51123
51124   {
51125     try {
51126       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51127     } catch (std::out_of_range& e) {
51128       {
51129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51130       };
51131     } catch (std::exception& e) {
51132       {
51133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51134       };
51135     } catch (Dali::DaliException e) {
51136       {
51137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51138       };
51139     } catch (...) {
51140       {
51141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51142       };
51143     }
51144   }
51145
51146   jresult = (void *)result;
51147   return jresult;
51148 }
51149
51150
51151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51152   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51153
51154   arg1 = (Dali::Vector< int > *)jarg1;
51155   {
51156     try {
51157       delete arg1;
51158     } catch (std::out_of_range& e) {
51159       {
51160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51161       };
51162     } catch (std::exception& e) {
51163       {
51164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51165       };
51166     } catch (Dali::DaliException e) {
51167       {
51168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51169       };
51170     } catch (...) {
51171       {
51172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51173       };
51174     }
51175   }
51176
51177 }
51178
51179
51180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51181   void * jresult ;
51182   Dali::Vector< int > *arg1 = 0 ;
51183   Dali::Vector< int > *result = 0 ;
51184
51185   arg1 = (Dali::Vector< int > *)jarg1;
51186   if (!arg1) {
51187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51188     return 0;
51189   }
51190   {
51191     try {
51192       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51193     } catch (std::out_of_range& e) {
51194       {
51195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51196       };
51197     } catch (std::exception& e) {
51198       {
51199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (Dali::DaliException e) {
51202       {
51203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211
51212   jresult = (void *)result;
51213   return jresult;
51214 }
51215
51216
51217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51218   void * jresult ;
51219   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51220   Dali::Vector< int > *arg2 = 0 ;
51221   Dali::Vector< int > *result = 0 ;
51222
51223   arg1 = (Dali::Vector< int > *)jarg1;
51224   arg2 = (Dali::Vector< int > *)jarg2;
51225   if (!arg2) {
51226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51227     return 0;
51228   }
51229   {
51230     try {
51231       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51232     } catch (std::out_of_range& e) {
51233       {
51234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51235       };
51236     } catch (std::exception& e) {
51237       {
51238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (Dali::DaliException e) {
51241       {
51242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51247       };
51248     }
51249   }
51250
51251   jresult = (void *)result;
51252   return jresult;
51253 }
51254
51255
51256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51257   void * jresult ;
51258   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51259   Dali::Vector< int >::Iterator result;
51260
51261   arg1 = (Dali::Vector< int > *)jarg1;
51262   {
51263     try {
51264       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51280       };
51281     }
51282   }
51283
51284   jresult = (void *)result;
51285   return jresult;
51286 }
51287
51288
51289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51290   void * jresult ;
51291   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51292   Dali::Vector< int >::Iterator result;
51293
51294   arg1 = (Dali::Vector< int > *)jarg1;
51295   {
51296     try {
51297       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51298     } catch (std::out_of_range& e) {
51299       {
51300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51301       };
51302     } catch (std::exception& e) {
51303       {
51304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (Dali::DaliException e) {
51307       {
51308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316
51317   jresult = (void *)result;
51318   return jresult;
51319 }
51320
51321
51322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51323   void * jresult ;
51324   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51325   Dali::Vector< int >::SizeType arg2 ;
51326   Dali::Vector< int >::ItemType *result = 0 ;
51327
51328   arg1 = (Dali::Vector< int > *)jarg1;
51329   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51330   {
51331     try {
51332       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (Dali::DaliException e) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51344       };
51345     } catch (...) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51348       };
51349     }
51350   }
51351
51352   jresult = (void *)result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51358   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51359   Dali::Vector< int >::ItemType *arg2 = 0 ;
51360   Dali::Vector< int >::ItemType temp2 ;
51361
51362   arg1 = (Dali::Vector< int > *)jarg1;
51363   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51364   arg2 = &temp2;
51365   {
51366     try {
51367       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51368     } catch (std::out_of_range& e) {
51369       {
51370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (std::exception& e) {
51373       {
51374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (Dali::DaliException e) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51379       };
51380     } catch (...) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51383       };
51384     }
51385   }
51386
51387 }
51388
51389
51390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51391   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51392   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51393   Dali::Vector< int >::ItemType *arg3 = 0 ;
51394   Dali::Vector< int >::ItemType temp3 ;
51395
51396   arg1 = (Dali::Vector< int > *)jarg1;
51397   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51398   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51399   arg3 = &temp3;
51400   {
51401     try {
51402       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51426   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51427   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51428   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51429   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51433   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51434   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51435   {
51436     try {
51437       (arg1)->Insert(arg2,arg3,arg4);
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (Dali::DaliException e) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51453       };
51454     }
51455   }
51456
51457 }
51458
51459
51460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51461   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51462   Dali::Vector< int >::SizeType arg2 ;
51463
51464   arg1 = (Dali::Vector< int > *)jarg1;
51465   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51466   {
51467     try {
51468       (arg1)->Reserve(arg2);
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51484       };
51485     }
51486   }
51487
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51493   Dali::Vector< int >::SizeType arg2 ;
51494
51495   arg1 = (Dali::Vector< int > *)jarg1;
51496   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51497   {
51498     try {
51499       (arg1)->Resize(arg2);
51500     } catch (std::out_of_range& e) {
51501       {
51502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51503       };
51504     } catch (std::exception& e) {
51505       {
51506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (Dali::DaliException e) {
51509       {
51510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51511       };
51512     } catch (...) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51515       };
51516     }
51517   }
51518
51519 }
51520
51521
51522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51523   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51524   Dali::Vector< int >::SizeType arg2 ;
51525   Dali::Vector< int >::ItemType *arg3 = 0 ;
51526   Dali::Vector< int >::ItemType temp3 ;
51527
51528   arg1 = (Dali::Vector< int > *)jarg1;
51529   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51530   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51531   arg3 = &temp3;
51532   {
51533     try {
51534       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51535     } catch (std::out_of_range& e) {
51536       {
51537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51538       };
51539     } catch (std::exception& e) {
51540       {
51541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (Dali::DaliException e) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51546       };
51547     } catch (...) {
51548       {
51549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51550       };
51551     }
51552   }
51553
51554 }
51555
51556
51557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51558   void * jresult ;
51559   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51560   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51561   Dali::Vector< int >::Iterator result;
51562
51563   arg1 = (Dali::Vector< int > *)jarg1;
51564   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51565   {
51566     try {
51567       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51575       };
51576     } catch (Dali::DaliException e) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51583       };
51584     }
51585   }
51586
51587   jresult = (void *)result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51593   void * jresult ;
51594   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51595   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51596   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51597   Dali::Vector< int >::Iterator result;
51598
51599   arg1 = (Dali::Vector< int > *)jarg1;
51600   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51601   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51602   {
51603     try {
51604       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51605     } catch (std::out_of_range& e) {
51606       {
51607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51608       };
51609     } catch (std::exception& e) {
51610       {
51611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51612       };
51613     } catch (Dali::DaliException e) {
51614       {
51615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51620       };
51621     }
51622   }
51623
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51630   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51631   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51632
51633   arg1 = (Dali::Vector< int > *)jarg1;
51634   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51635   {
51636     try {
51637       (arg1)->Remove(arg2);
51638     } catch (std::out_of_range& e) {
51639       {
51640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51641       };
51642     } catch (std::exception& e) {
51643       {
51644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51645       };
51646     } catch (Dali::DaliException e) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51649       };
51650     } catch (...) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51653       };
51654     }
51655   }
51656
51657 }
51658
51659
51660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51662   Dali::Vector< int > *arg2 = 0 ;
51663
51664   arg1 = (Dali::Vector< int > *)jarg1;
51665   arg2 = (Dali::Vector< int > *)jarg2;
51666   if (!arg2) {
51667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51668     return ;
51669   }
51670   {
51671     try {
51672       (arg1)->Swap(*arg2);
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51688       };
51689     }
51690   }
51691
51692 }
51693
51694
51695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51696   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51697
51698   arg1 = (Dali::Vector< int > *)jarg1;
51699   {
51700     try {
51701       (arg1)->Clear();
51702     } catch (std::out_of_range& e) {
51703       {
51704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51705       };
51706     } catch (std::exception& e) {
51707       {
51708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51709       };
51710     } catch (Dali::DaliException e) {
51711       {
51712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51713       };
51714     } catch (...) {
51715       {
51716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51717       };
51718     }
51719   }
51720
51721 }
51722
51723
51724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51725   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51726
51727   arg1 = (Dali::Vector< int > *)jarg1;
51728   {
51729     try {
51730       (arg1)->Release();
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (Dali::DaliException e) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51742       };
51743     } catch (...) {
51744       {
51745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51746       };
51747     }
51748   }
51749
51750 }
51751
51752
51753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51754   int jresult ;
51755   int result;
51756
51757   result = (int)Dali::Vector< float >::BaseType;
51758   jresult = (int)result;
51759   return jresult;
51760 }
51761
51762
51763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51764   void * jresult ;
51765   Dali::Vector< float > *result = 0 ;
51766
51767   {
51768     try {
51769       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51770     } catch (std::out_of_range& e) {
51771       {
51772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51773       };
51774     } catch (std::exception& e) {
51775       {
51776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51777       };
51778     } catch (Dali::DaliException e) {
51779       {
51780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51781       };
51782     } catch (...) {
51783       {
51784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51785       };
51786     }
51787   }
51788
51789   jresult = (void *)result;
51790   return jresult;
51791 }
51792
51793
51794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51795   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51796
51797   arg1 = (Dali::Vector< float > *)jarg1;
51798   {
51799     try {
51800       delete arg1;
51801     } catch (std::out_of_range& e) {
51802       {
51803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (std::exception& e) {
51806       {
51807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51808       };
51809     } catch (Dali::DaliException e) {
51810       {
51811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51812       };
51813     } catch (...) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51816       };
51817     }
51818   }
51819
51820 }
51821
51822
51823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51824   void * jresult ;
51825   Dali::Vector< float > *arg1 = 0 ;
51826   Dali::Vector< float > *result = 0 ;
51827
51828   arg1 = (Dali::Vector< float > *)jarg1;
51829   if (!arg1) {
51830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51831     return 0;
51832   }
51833   {
51834     try {
51835       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51836     } catch (std::out_of_range& e) {
51837       {
51838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51839       };
51840     } catch (std::exception& e) {
51841       {
51842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51843       };
51844     } catch (Dali::DaliException e) {
51845       {
51846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51847       };
51848     } catch (...) {
51849       {
51850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51851       };
51852     }
51853   }
51854
51855   jresult = (void *)result;
51856   return jresult;
51857 }
51858
51859
51860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51861   void * jresult ;
51862   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51863   Dali::Vector< float > *arg2 = 0 ;
51864   Dali::Vector< float > *result = 0 ;
51865
51866   arg1 = (Dali::Vector< float > *)jarg1;
51867   arg2 = (Dali::Vector< float > *)jarg2;
51868   if (!arg2) {
51869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51870     return 0;
51871   }
51872   {
51873     try {
51874       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (Dali::DaliException e) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51886       };
51887     } catch (...) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51890       };
51891     }
51892   }
51893
51894   jresult = (void *)result;
51895   return jresult;
51896 }
51897
51898
51899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51900   void * jresult ;
51901   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51902   Dali::Vector< float >::Iterator result;
51903
51904   arg1 = (Dali::Vector< float > *)jarg1;
51905   {
51906     try {
51907       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51908     } catch (std::out_of_range& e) {
51909       {
51910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51911       };
51912     } catch (std::exception& e) {
51913       {
51914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51915       };
51916     } catch (Dali::DaliException e) {
51917       {
51918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51919       };
51920     } catch (...) {
51921       {
51922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51923       };
51924     }
51925   }
51926
51927   jresult = (void *)result;
51928   return jresult;
51929 }
51930
51931
51932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51933   void * jresult ;
51934   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51935   Dali::Vector< float >::Iterator result;
51936
51937   arg1 = (Dali::Vector< float > *)jarg1;
51938   {
51939     try {
51940       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51941     } catch (std::out_of_range& e) {
51942       {
51943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (std::exception& e) {
51946       {
51947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51948       };
51949     } catch (Dali::DaliException e) {
51950       {
51951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51952       };
51953     } catch (...) {
51954       {
51955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51956       };
51957     }
51958   }
51959
51960   jresult = (void *)result;
51961   return jresult;
51962 }
51963
51964
51965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51966   void * jresult ;
51967   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51968   Dali::Vector< float >::SizeType arg2 ;
51969   Dali::Vector< float >::ItemType *result = 0 ;
51970
51971   arg1 = (Dali::Vector< float > *)jarg1;
51972   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51973   {
51974     try {
51975       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51976     } catch (std::out_of_range& e) {
51977       {
51978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51979       };
51980     } catch (std::exception& e) {
51981       {
51982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (Dali::DaliException e) {
51985       {
51986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51987       };
51988     } catch (...) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51991       };
51992     }
51993   }
51994
51995   jresult = (void *)result;
51996   return jresult;
51997 }
51998
51999
52000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
52001   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52002   Dali::Vector< float >::ItemType *arg2 = 0 ;
52003   Dali::Vector< float >::ItemType temp2 ;
52004
52005   arg1 = (Dali::Vector< float > *)jarg1;
52006   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52007   arg2 = &temp2;
52008   {
52009     try {
52010       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52011     } catch (std::out_of_range& e) {
52012       {
52013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52014       };
52015     } catch (std::exception& e) {
52016       {
52017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52018       };
52019     } catch (Dali::DaliException e) {
52020       {
52021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52022       };
52023     } catch (...) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52026       };
52027     }
52028   }
52029
52030 }
52031
52032
52033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52034   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52035   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52036   Dali::Vector< float >::ItemType *arg3 = 0 ;
52037   Dali::Vector< float >::ItemType temp3 ;
52038
52039   arg1 = (Dali::Vector< float > *)jarg1;
52040   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52041   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52042   arg3 = &temp3;
52043   {
52044     try {
52045       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52046     } catch (std::out_of_range& e) {
52047       {
52048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52049       };
52050     } catch (std::exception& e) {
52051       {
52052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (Dali::DaliException e) {
52055       {
52056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52061       };
52062     }
52063   }
52064
52065 }
52066
52067
52068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52069   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52070   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52071   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52072   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52073
52074   arg1 = (Dali::Vector< float > *)jarg1;
52075   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52076   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52077   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52078   {
52079     try {
52080       (arg1)->Insert(arg2,arg3,arg4);
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52088       };
52089     } catch (Dali::DaliException e) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52092       };
52093     } catch (...) {
52094       {
52095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52096       };
52097     }
52098   }
52099
52100 }
52101
52102
52103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52104   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52105   Dali::Vector< float >::SizeType arg2 ;
52106
52107   arg1 = (Dali::Vector< float > *)jarg1;
52108   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52109   {
52110     try {
52111       (arg1)->Reserve(arg2);
52112     } catch (std::out_of_range& e) {
52113       {
52114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52115       };
52116     } catch (std::exception& e) {
52117       {
52118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52119       };
52120     } catch (Dali::DaliException e) {
52121       {
52122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52123       };
52124     } catch (...) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52127       };
52128     }
52129   }
52130
52131 }
52132
52133 //// ========================= end of part 2 =============================
52134
52135 //// ========================== start part 3 ===============================
52136
52137
52138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52139   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52140   Dali::Vector< float >::SizeType arg2 ;
52141
52142   arg1 = (Dali::Vector< float > *)jarg1;
52143   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52144   {
52145     try {
52146       (arg1)->Resize(arg2);
52147     } catch (std::out_of_range& e) {
52148       {
52149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52150       };
52151     } catch (std::exception& e) {
52152       {
52153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52154       };
52155     } catch (Dali::DaliException e) {
52156       {
52157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52158       };
52159     } catch (...) {
52160       {
52161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52162       };
52163     }
52164   }
52165
52166 }
52167
52168
52169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52170   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52171   Dali::Vector< float >::SizeType arg2 ;
52172   Dali::Vector< float >::ItemType *arg3 = 0 ;
52173   Dali::Vector< float >::ItemType temp3 ;
52174
52175   arg1 = (Dali::Vector< float > *)jarg1;
52176   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52177   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52178   arg3 = &temp3;
52179   {
52180     try {
52181       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52182     } catch (std::out_of_range& e) {
52183       {
52184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52185       };
52186     } catch (std::exception& e) {
52187       {
52188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52189       };
52190     } catch (Dali::DaliException e) {
52191       {
52192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52193       };
52194     } catch (...) {
52195       {
52196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52197       };
52198     }
52199   }
52200
52201 }
52202
52203
52204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52205   void * jresult ;
52206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52207   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52208   Dali::Vector< float >::Iterator result;
52209
52210   arg1 = (Dali::Vector< float > *)jarg1;
52211   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52212   {
52213     try {
52214       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52230       };
52231     }
52232   }
52233
52234   jresult = (void *)result;
52235   return jresult;
52236 }
52237
52238
52239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52240   void * jresult ;
52241   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52242   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52243   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52244   Dali::Vector< float >::Iterator result;
52245
52246   arg1 = (Dali::Vector< float > *)jarg1;
52247   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52248   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52249   {
52250     try {
52251       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52252     } catch (std::out_of_range& e) {
52253       {
52254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52255       };
52256     } catch (std::exception& e) {
52257       {
52258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (Dali::DaliException e) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52267       };
52268     }
52269   }
52270
52271   jresult = (void *)result;
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52277   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52278   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52279
52280   arg1 = (Dali::Vector< float > *)jarg1;
52281   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52282   {
52283     try {
52284       (arg1)->Remove(arg2);
52285     } catch (std::out_of_range& e) {
52286       {
52287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (std::exception& e) {
52290       {
52291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (Dali::DaliException e) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52296       };
52297     } catch (...) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52300       };
52301     }
52302   }
52303
52304 }
52305
52306
52307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52308   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52309   Dali::Vector< float > *arg2 = 0 ;
52310
52311   arg1 = (Dali::Vector< float > *)jarg1;
52312   arg2 = (Dali::Vector< float > *)jarg2;
52313   if (!arg2) {
52314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52315     return ;
52316   }
52317   {
52318     try {
52319       (arg1)->Swap(*arg2);
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52327       };
52328     } catch (Dali::DaliException e) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52335       };
52336     }
52337   }
52338
52339 }
52340
52341
52342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52343   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52344
52345   arg1 = (Dali::Vector< float > *)jarg1;
52346   {
52347     try {
52348       (arg1)->Clear();
52349     } catch (std::out_of_range& e) {
52350       {
52351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52352       };
52353     } catch (std::exception& e) {
52354       {
52355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52356       };
52357     } catch (Dali::DaliException e) {
52358       {
52359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52360       };
52361     } catch (...) {
52362       {
52363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52364       };
52365     }
52366   }
52367
52368 }
52369
52370
52371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52372   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52373
52374   arg1 = (Dali::Vector< float > *)jarg1;
52375   {
52376     try {
52377       (arg1)->Release();
52378     } catch (std::out_of_range& e) {
52379       {
52380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52381       };
52382     } catch (std::exception& e) {
52383       {
52384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52385       };
52386     } catch (Dali::DaliException e) {
52387       {
52388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52389       };
52390     } catch (...) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52393       };
52394     }
52395   }
52396
52397 }
52398
52399
52400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52401   int jresult ;
52402   int result;
52403
52404   result = (int)Dali::Vector< unsigned char >::BaseType;
52405   jresult = (int)result;
52406   return jresult;
52407 }
52408
52409
52410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52411   void * jresult ;
52412   Dali::Vector< unsigned char > *result = 0 ;
52413
52414   {
52415     try {
52416       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52417     } catch (std::out_of_range& e) {
52418       {
52419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52420       };
52421     } catch (std::exception& e) {
52422       {
52423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52424       };
52425     } catch (Dali::DaliException e) {
52426       {
52427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52428       };
52429     } catch (...) {
52430       {
52431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52432       };
52433     }
52434   }
52435
52436   jresult = (void *)result;
52437   return jresult;
52438 }
52439
52440
52441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52442   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52443
52444   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52445   {
52446     try {
52447       delete arg1;
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52455       };
52456     } catch (Dali::DaliException e) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52459       };
52460     } catch (...) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52463       };
52464     }
52465   }
52466
52467 }
52468
52469
52470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52471   void * jresult ;
52472   Dali::Vector< unsigned char > *arg1 = 0 ;
52473   Dali::Vector< unsigned char > *result = 0 ;
52474
52475   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52476   if (!arg1) {
52477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52478     return 0;
52479   }
52480   {
52481     try {
52482       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52483     } catch (std::out_of_range& e) {
52484       {
52485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (std::exception& e) {
52488       {
52489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52490       };
52491     } catch (Dali::DaliException e) {
52492       {
52493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52494       };
52495     } catch (...) {
52496       {
52497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52498       };
52499     }
52500   }
52501
52502   jresult = (void *)result;
52503   return jresult;
52504 }
52505
52506
52507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52508   void * jresult ;
52509   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52510   Dali::Vector< unsigned char > *arg2 = 0 ;
52511   Dali::Vector< unsigned char > *result = 0 ;
52512
52513   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52514   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52515   if (!arg2) {
52516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52517     return 0;
52518   }
52519   {
52520     try {
52521       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52522     } catch (std::out_of_range& e) {
52523       {
52524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52525       };
52526     } catch (std::exception& e) {
52527       {
52528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (Dali::DaliException e) {
52531       {
52532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52533       };
52534     } catch (...) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52537       };
52538     }
52539   }
52540
52541   jresult = (void *)result;
52542   return jresult;
52543 }
52544
52545
52546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52547   void * jresult ;
52548   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52549   Dali::Vector< unsigned char >::Iterator result;
52550
52551   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52552   {
52553     try {
52554       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (Dali::DaliException e) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52566       };
52567     } catch (...) {
52568       {
52569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52570       };
52571     }
52572   }
52573
52574   jresult = (void *)result;
52575   return jresult;
52576 }
52577
52578
52579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52580   void * jresult ;
52581   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52582   Dali::Vector< unsigned char >::Iterator result;
52583
52584   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52585   {
52586     try {
52587       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52588     } catch (std::out_of_range& e) {
52589       {
52590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52591       };
52592     } catch (std::exception& e) {
52593       {
52594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52595       };
52596     } catch (Dali::DaliException e) {
52597       {
52598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52599       };
52600     } catch (...) {
52601       {
52602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52603       };
52604     }
52605   }
52606
52607   jresult = (void *)result;
52608   return jresult;
52609 }
52610
52611
52612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52613   void * jresult ;
52614   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52615   Dali::Vector< unsigned char >::SizeType arg2 ;
52616   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52617
52618   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52619   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52620   {
52621     try {
52622       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52623     } catch (std::out_of_range& e) {
52624       {
52625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52626       };
52627     } catch (std::exception& e) {
52628       {
52629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52630       };
52631     } catch (Dali::DaliException e) {
52632       {
52633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52634       };
52635     } catch (...) {
52636       {
52637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52638       };
52639     }
52640   }
52641
52642   jresult = (void *)result;
52643   return jresult;
52644 }
52645
52646
52647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52648   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52649   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52650   Dali::Vector< unsigned char >::ItemType temp2 ;
52651
52652   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52653   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52654   arg2 = &temp2;
52655   {
52656     try {
52657       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52658     } catch (std::out_of_range& e) {
52659       {
52660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52661       };
52662     } catch (std::exception& e) {
52663       {
52664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52665       };
52666     } catch (Dali::DaliException e) {
52667       {
52668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52669       };
52670     } catch (...) {
52671       {
52672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52673       };
52674     }
52675   }
52676
52677 }
52678
52679
52680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52681   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52682   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52683   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52684   Dali::Vector< unsigned char >::ItemType temp3 ;
52685
52686   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52687   arg2 = jarg2;
52688   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52689   arg3 = &temp3;
52690   {
52691     try {
52692       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52693     } catch (std::out_of_range& e) {
52694       {
52695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52696       };
52697     } catch (std::exception& e) {
52698       {
52699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52700       };
52701     } catch (Dali::DaliException e) {
52702       {
52703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52704       };
52705     } catch (...) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52708       };
52709     }
52710   }
52711
52712
52713
52714 }
52715
52716
52717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52718   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52719   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52720   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52721   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52722
52723   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52724   arg2 = jarg2;
52725   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52726   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52727   {
52728     try {
52729       (arg1)->Insert(arg2,arg3,arg4);
52730     } catch (std::out_of_range& e) {
52731       {
52732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52733       };
52734     } catch (std::exception& e) {
52735       {
52736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52737       };
52738     } catch (Dali::DaliException e) {
52739       {
52740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52745       };
52746     }
52747   }
52748
52749
52750
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52756   Dali::Vector< unsigned char >::SizeType arg2 ;
52757
52758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52759   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52760   {
52761     try {
52762       (arg1)->Reserve(arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (Dali::DaliException e) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52774       };
52775     } catch (...) {
52776       {
52777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52778       };
52779     }
52780   }
52781
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52786   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52787   Dali::Vector< unsigned char >::SizeType arg2 ;
52788
52789   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52790   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52791   {
52792     try {
52793       (arg1)->Resize(arg2);
52794     } catch (std::out_of_range& e) {
52795       {
52796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52797       };
52798     } catch (std::exception& e) {
52799       {
52800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52801       };
52802     } catch (Dali::DaliException e) {
52803       {
52804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52805       };
52806     } catch (...) {
52807       {
52808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52809       };
52810     }
52811   }
52812
52813 }
52814
52815
52816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52817   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52818   Dali::Vector< unsigned char >::SizeType arg2 ;
52819   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52820   Dali::Vector< unsigned char >::ItemType temp3 ;
52821
52822   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52823   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52824   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52825   arg3 = &temp3;
52826   {
52827     try {
52828       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52829     } catch (std::out_of_range& e) {
52830       {
52831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (std::exception& e) {
52834       {
52835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52836       };
52837     } catch (Dali::DaliException e) {
52838       {
52839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52840       };
52841     } catch (...) {
52842       {
52843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52844       };
52845     }
52846   }
52847
52848 }
52849
52850
52851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52852   void * jresult ;
52853   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52854   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52855   Dali::Vector< unsigned char >::Iterator result;
52856
52857   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52858   arg2 = jarg2;
52859   {
52860     try {
52861       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52862     } catch (std::out_of_range& e) {
52863       {
52864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52865       };
52866     } catch (std::exception& e) {
52867       {
52868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (Dali::DaliException e) {
52871       {
52872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52873       };
52874     } catch (...) {
52875       {
52876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52877       };
52878     }
52879   }
52880
52881   jresult = (void *)result;
52882
52883
52884   return jresult;
52885 }
52886
52887
52888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52889   void * jresult ;
52890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52891   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52892   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52893   Dali::Vector< unsigned char >::Iterator result;
52894
52895   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52896   arg2 = jarg2;
52897   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52898   {
52899     try {
52900       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52908       };
52909     } catch (Dali::DaliException e) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52912       };
52913     } catch (...) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52916       };
52917     }
52918   }
52919
52920   jresult = (void *)result;
52921
52922
52923   return jresult;
52924 }
52925
52926
52927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52929   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52930
52931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52932   arg2 = jarg2;
52933   {
52934     try {
52935       (arg1)->Remove(arg2);
52936     } catch (std::out_of_range& e) {
52937       {
52938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52939       };
52940     } catch (std::exception& e) {
52941       {
52942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (Dali::DaliException e) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52947       };
52948     } catch (...) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52951       };
52952     }
52953   }
52954
52955
52956
52957 }
52958
52959
52960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52961   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52962   Dali::Vector< unsigned char > *arg2 = 0 ;
52963
52964   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52965   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52966   if (!arg2) {
52967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52968     return ;
52969   }
52970   {
52971     try {
52972       (arg1)->Swap(*arg2);
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52988       };
52989     }
52990   }
52991
52992 }
52993
52994
52995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52996   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52997
52998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52999   {
53000     try {
53001       (arg1)->Clear();
53002     } catch (std::out_of_range& e) {
53003       {
53004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (std::exception& e) {
53007       {
53008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53009       };
53010     } catch (Dali::DaliException e) {
53011       {
53012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53013       };
53014     } catch (...) {
53015       {
53016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53017       };
53018     }
53019   }
53020
53021 }
53022
53023
53024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53025   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53026
53027   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53028   {
53029     try {
53030       (arg1)->Release();
53031     } catch (std::out_of_range& e) {
53032       {
53033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53034       };
53035     } catch (std::exception& e) {
53036       {
53037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53038       };
53039     } catch (Dali::DaliException e) {
53040       {
53041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53042       };
53043     } catch (...) {
53044       {
53045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53046       };
53047     }
53048   }
53049
53050 }
53051
53052
53053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53054   int jresult ;
53055   int result;
53056
53057   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53058   jresult = (int)result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53064   void * jresult ;
53065   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53066
53067   {
53068     try {
53069       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (Dali::DaliException e) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088
53089   jresult = (void *)result;
53090   return jresult;
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53095   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53096
53097   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53098   {
53099     try {
53100       delete arg1;
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (Dali::DaliException e) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53112       };
53113     } catch (...) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53116       };
53117     }
53118   }
53119
53120 }
53121
53122
53123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53124   void * jresult ;
53125   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53126   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53127
53128   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53129   if (!arg1) {
53130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53131     return 0;
53132   }
53133   {
53134     try {
53135       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53136     } catch (std::out_of_range& e) {
53137       {
53138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53139       };
53140     } catch (std::exception& e) {
53141       {
53142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53143       };
53144     } catch (Dali::DaliException e) {
53145       {
53146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53147       };
53148     } catch (...) {
53149       {
53150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53151       };
53152     }
53153   }
53154
53155   jresult = (void *)result;
53156   return jresult;
53157 }
53158
53159
53160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53161   void * jresult ;
53162   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53163   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53164   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53165
53166   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53167   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53168   if (!arg2) {
53169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53170     return 0;
53171   }
53172   {
53173     try {
53174       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53175     } catch (std::out_of_range& e) {
53176       {
53177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53178       };
53179     } catch (std::exception& e) {
53180       {
53181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53182       };
53183     } catch (Dali::DaliException e) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53186       };
53187     } catch (...) {
53188       {
53189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53190       };
53191     }
53192   }
53193
53194   jresult = (void *)result;
53195   return jresult;
53196 }
53197
53198
53199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53200   void * jresult ;
53201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53202   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53203
53204   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53205   {
53206     try {
53207       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (Dali::DaliException e) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53219       };
53220     } catch (...) {
53221       {
53222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53223       };
53224     }
53225   }
53226
53227   jresult = (void *)result;
53228   return jresult;
53229 }
53230
53231
53232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53233   void * jresult ;
53234   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53235   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53236
53237   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53238   {
53239     try {
53240       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53241     } catch (std::out_of_range& e) {
53242       {
53243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53244       };
53245     } catch (std::exception& e) {
53246       {
53247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53248       };
53249     } catch (Dali::DaliException e) {
53250       {
53251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53252       };
53253     } catch (...) {
53254       {
53255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53256       };
53257     }
53258   }
53259
53260   jresult = (void *)result;
53261   return jresult;
53262 }
53263
53264
53265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53266   void * jresult ;
53267   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53268   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53269   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53270
53271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53272   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53273   {
53274     try {
53275       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53276     } catch (std::out_of_range& e) {
53277       {
53278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53279       };
53280     } catch (std::exception& e) {
53281       {
53282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53283       };
53284     } catch (Dali::DaliException e) {
53285       {
53286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53287       };
53288     } catch (...) {
53289       {
53290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53291       };
53292     }
53293   }
53294
53295   jresult = (void *)result;
53296   return jresult;
53297 }
53298
53299
53300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53302   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53303
53304   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53305   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53306   if (!arg2) {
53307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53308     return ;
53309   }
53310   {
53311     try {
53312       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53313     } catch (std::out_of_range& e) {
53314       {
53315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53316       };
53317     } catch (std::exception& e) {
53318       {
53319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53320       };
53321     } catch (Dali::DaliException e) {
53322       {
53323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53324       };
53325     } catch (...) {
53326       {
53327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53328       };
53329     }
53330   }
53331
53332 }
53333
53334
53335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53336   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53337   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53338   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53339
53340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53341   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53342   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53343   if (!arg3) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53345     return ;
53346   }
53347   {
53348     try {
53349       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53350     } catch (std::out_of_range& e) {
53351       {
53352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53353       };
53354     } catch (std::exception& e) {
53355       {
53356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53357       };
53358     } catch (Dali::DaliException e) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53361       };
53362     } catch (...) {
53363       {
53364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53365       };
53366     }
53367   }
53368
53369 }
53370
53371
53372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53374   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53376   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53380   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53381   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53382   {
53383     try {
53384       (arg1)->Insert(arg2,arg3,arg4);
53385     } catch (std::out_of_range& e) {
53386       {
53387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53388       };
53389     } catch (std::exception& e) {
53390       {
53391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (Dali::DaliException e) {
53394       {
53395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403
53404 }
53405
53406
53407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53408   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53409   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53410
53411   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53412   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53413   {
53414     try {
53415       (arg1)->Reserve(arg2);
53416     } catch (std::out_of_range& e) {
53417       {
53418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53419       };
53420     } catch (std::exception& e) {
53421       {
53422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53423       };
53424     } catch (Dali::DaliException e) {
53425       {
53426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53427       };
53428     } catch (...) {
53429       {
53430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53431       };
53432     }
53433   }
53434
53435 }
53436
53437
53438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53440   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53441
53442   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53443   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53444   {
53445     try {
53446       (arg1)->Resize(arg2);
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (Dali::DaliException e) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53462       };
53463     }
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53470   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53471   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53472   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53473
53474   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53475   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53476   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53477   if (!arg3) {
53478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53479     return ;
53480   }
53481   {
53482     try {
53483       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53484     } catch (std::out_of_range& e) {
53485       {
53486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53487       };
53488     } catch (std::exception& e) {
53489       {
53490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53491       };
53492     } catch (Dali::DaliException e) {
53493       {
53494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53495       };
53496     } catch (...) {
53497       {
53498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53499       };
53500     }
53501   }
53502
53503 }
53504
53505
53506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53507   void * jresult ;
53508   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53509   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53510   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53511
53512   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53513   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53514   {
53515     try {
53516       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53517     } catch (std::out_of_range& e) {
53518       {
53519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53520       };
53521     } catch (std::exception& e) {
53522       {
53523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53524       };
53525     } catch (Dali::DaliException e) {
53526       {
53527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53528       };
53529     } catch (...) {
53530       {
53531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53532       };
53533     }
53534   }
53535
53536   jresult = (void *)result;
53537   return jresult;
53538 }
53539
53540
53541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53542   void * jresult ;
53543   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53544   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53545   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53546   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53547
53548   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53549   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53550   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53551   {
53552     try {
53553       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (Dali::DaliException e) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53565       };
53566     } catch (...) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53569       };
53570     }
53571   }
53572
53573   jresult = (void *)result;
53574   return jresult;
53575 }
53576
53577
53578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53579   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53580   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53581
53582   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53583   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53584   {
53585     try {
53586       (arg1)->Remove(arg2);
53587     } catch (std::out_of_range& e) {
53588       {
53589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (std::exception& e) {
53592       {
53593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (Dali::DaliException e) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53598       };
53599     } catch (...) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53602       };
53603     }
53604   }
53605
53606 }
53607
53608
53609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53610   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53611   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53612
53613   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53614   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53615   if (!arg2) {
53616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53617     return ;
53618   }
53619   {
53620     try {
53621       (arg1)->Swap(*arg2);
53622     } catch (std::out_of_range& e) {
53623       {
53624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53625       };
53626     } catch (std::exception& e) {
53627       {
53628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53629       };
53630     } catch (Dali::DaliException e) {
53631       {
53632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53633       };
53634     } catch (...) {
53635       {
53636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53637       };
53638     }
53639   }
53640
53641 }
53642
53643
53644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53645   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53646
53647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53648   {
53649     try {
53650       (arg1)->Clear();
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53666       };
53667     }
53668   }
53669
53670 }
53671
53672
53673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53674   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53675
53676   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53677   {
53678     try {
53679       (arg1)->Release();
53680     } catch (std::out_of_range& e) {
53681       {
53682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53683       };
53684     } catch (std::exception& e) {
53685       {
53686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53687       };
53688     } catch (Dali::DaliException e) {
53689       {
53690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53691       };
53692     } catch (...) {
53693       {
53694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53695       };
53696     }
53697   }
53698
53699 }
53700
53701
53702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53703   void * jresult ;
53704   Dali::Signal< void () > *result = 0 ;
53705
53706   {
53707     try {
53708       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53709     } catch (std::out_of_range& e) {
53710       {
53711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53712       };
53713     } catch (std::exception& e) {
53714       {
53715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53716       };
53717     } catch (Dali::DaliException e) {
53718       {
53719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53720       };
53721     } catch (...) {
53722       {
53723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53724       };
53725     }
53726   }
53727
53728   jresult = (void *)result;
53729   return jresult;
53730 }
53731
53732
53733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53734   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53735
53736   arg1 = (Dali::Signal< void () > *)jarg1;
53737   {
53738     try {
53739       delete arg1;
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53747       };
53748     } catch (Dali::DaliException e) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53751       };
53752     } catch (...) {
53753       {
53754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53755       };
53756     }
53757   }
53758
53759 }
53760
53761
53762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53763   unsigned int jresult ;
53764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53765   bool result;
53766
53767   arg1 = (Dali::Signal< void () > *)jarg1;
53768   {
53769     try {
53770       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789
53790   jresult = result;
53791   return jresult;
53792 }
53793
53794
53795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53796   unsigned long jresult ;
53797   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53798   std::size_t result;
53799
53800   arg1 = (Dali::Signal< void () > *)jarg1;
53801   {
53802     try {
53803       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53804     } catch (std::out_of_range& e) {
53805       {
53806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53807       };
53808     } catch (std::exception& e) {
53809       {
53810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53811       };
53812     } catch (Dali::DaliException e) {
53813       {
53814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53815       };
53816     } catch (...) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53819       };
53820     }
53821   }
53822
53823   jresult = (unsigned long)result;
53824   return jresult;
53825 }
53826
53827
53828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53829   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53830   void (*arg2)() = (void (*)()) 0 ;
53831
53832   arg1 = (Dali::Signal< void () > *)jarg1;
53833   arg2 = (void (*)())jarg2;
53834   {
53835     try {
53836       (arg1)->Connect(arg2);
53837     } catch (std::out_of_range& e) {
53838       {
53839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53840       };
53841     } catch (std::exception& e) {
53842       {
53843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53844       };
53845     } catch (Dali::DaliException e) {
53846       {
53847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53852       };
53853     }
53854   }
53855
53856 }
53857
53858
53859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53860   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53861   void (*arg2)() = (void (*)()) 0 ;
53862
53863   arg1 = (Dali::Signal< void () > *)jarg1;
53864   arg2 = (void (*)())jarg2;
53865   {
53866     try {
53867       (arg1)->Disconnect(arg2);
53868     } catch (std::out_of_range& e) {
53869       {
53870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53871       };
53872     } catch (std::exception& e) {
53873       {
53874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53875       };
53876     } catch (Dali::DaliException e) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53879       };
53880     } catch (...) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53883       };
53884     }
53885   }
53886
53887 }
53888
53889
53890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53891   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53892   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53893   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53894
53895   arg1 = (Dali::Signal< void () > *)jarg1;
53896   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53897   arg3 = (Dali::FunctorDelegate *)jarg3;
53898   {
53899     try {
53900       (arg1)->Connect(arg2,arg3);
53901     } catch (std::out_of_range& e) {
53902       {
53903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53904       };
53905     } catch (std::exception& e) {
53906       {
53907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (Dali::DaliException e) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53912       };
53913     } catch (...) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53916       };
53917     }
53918   }
53919
53920 }
53921
53922
53923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53925
53926   arg1 = (Dali::Signal< void () > *)jarg1;
53927   {
53928     try {
53929       (arg1)->Emit();
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53937       };
53938     } catch (Dali::DaliException e) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53945       };
53946     }
53947   }
53948
53949 }
53950
53951
53952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53953   unsigned int jresult ;
53954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53955   bool result;
53956
53957   arg1 = (Dali::Signal< void (float) > *)jarg1;
53958   {
53959     try {
53960       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53961     } catch (std::out_of_range& e) {
53962       {
53963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53964       };
53965     } catch (std::exception& e) {
53966       {
53967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53968       };
53969     } catch (Dali::DaliException e) {
53970       {
53971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53976       };
53977     }
53978   }
53979
53980   jresult = result;
53981   return jresult;
53982 }
53983
53984
53985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53986   unsigned long jresult ;
53987   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53988   std::size_t result;
53989
53990   arg1 = (Dali::Signal< void (float) > *)jarg1;
53991   {
53992     try {
53993       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53994     } catch (std::out_of_range& e) {
53995       {
53996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53997       };
53998     } catch (std::exception& e) {
53999       {
54000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54001       };
54002     } catch (Dali::DaliException e) {
54003       {
54004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54005       };
54006     } catch (...) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54009       };
54010     }
54011   }
54012
54013   jresult = (unsigned long)result;
54014   return jresult;
54015 }
54016
54017
54018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54019   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54020   void (*arg2)(float) = (void (*)(float)) 0 ;
54021
54022   arg1 = (Dali::Signal< void (float) > *)jarg1;
54023   arg2 = (void (*)(float))jarg2;
54024   {
54025     try {
54026       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54034       };
54035     } catch (Dali::DaliException e) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54038       };
54039     } catch (...) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54042       };
54043     }
54044   }
54045
54046 }
54047
54048
54049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54050   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54051   void (*arg2)(float) = (void (*)(float)) 0 ;
54052
54053   arg1 = (Dali::Signal< void (float) > *)jarg1;
54054   arg2 = (void (*)(float))jarg2;
54055   {
54056     try {
54057       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54058     } catch (std::out_of_range& e) {
54059       {
54060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54061       };
54062     } catch (std::exception& e) {
54063       {
54064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54065       };
54066     } catch (Dali::DaliException e) {
54067       {
54068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54069       };
54070     } catch (...) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54073       };
54074     }
54075   }
54076
54077 }
54078
54079
54080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54081   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54082   float arg2 ;
54083
54084   arg1 = (Dali::Signal< void (float) > *)jarg1;
54085   arg2 = (float)jarg2;
54086   {
54087     try {
54088       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54089     } catch (std::out_of_range& e) {
54090       {
54091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54092       };
54093     } catch (std::exception& e) {
54094       {
54095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54096       };
54097     } catch (Dali::DaliException e) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54100       };
54101     } catch (...) {
54102       {
54103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54104       };
54105     }
54106   }
54107
54108 }
54109
54110
54111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54112   void * jresult ;
54113   Dali::Signal< void (float) > *result = 0 ;
54114
54115   {
54116     try {
54117       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54118     } catch (std::out_of_range& e) {
54119       {
54120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54121       };
54122     } catch (std::exception& e) {
54123       {
54124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54125       };
54126     } catch (Dali::DaliException e) {
54127       {
54128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54129       };
54130     } catch (...) {
54131       {
54132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54133       };
54134     }
54135   }
54136
54137   jresult = (void *)result;
54138   return jresult;
54139 }
54140
54141
54142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54143   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54144
54145   arg1 = (Dali::Signal< void (float) > *)jarg1;
54146   {
54147     try {
54148       delete arg1;
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54156       };
54157     } catch (Dali::DaliException e) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54164       };
54165     }
54166   }
54167
54168 }
54169
54170
54171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54172   unsigned int jresult ;
54173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54174   bool result;
54175
54176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54177   {
54178     try {
54179       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54187       };
54188     } catch (Dali::DaliException e) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54191       };
54192     } catch (...) {
54193       {
54194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54195       };
54196     }
54197   }
54198
54199   jresult = result;
54200   return jresult;
54201 }
54202
54203
54204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54205   unsigned long jresult ;
54206   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54207   std::size_t result;
54208
54209   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54210   {
54211     try {
54212       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54213     } catch (std::out_of_range& e) {
54214       {
54215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (std::exception& e) {
54218       {
54219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54220       };
54221     } catch (Dali::DaliException e) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54228       };
54229     }
54230   }
54231
54232   jresult = (unsigned long)result;
54233   return jresult;
54234 }
54235
54236
54237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54238   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54239   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54240
54241   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54242   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54243   {
54244     try {
54245       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54246     } catch (std::out_of_range& e) {
54247       {
54248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54249       };
54250     } catch (std::exception& e) {
54251       {
54252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54253       };
54254     } catch (Dali::DaliException e) {
54255       {
54256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54257       };
54258     } catch (...) {
54259       {
54260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54261       };
54262     }
54263   }
54264
54265 }
54266
54267
54268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54271
54272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54274   {
54275     try {
54276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54284       };
54285     } catch (Dali::DaliException e) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54288       };
54289     } catch (...) {
54290       {
54291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54292       };
54293     }
54294   }
54295
54296 }
54297
54298
54299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54300   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54301   Dali::BaseHandle arg2 ;
54302   Dali::BaseHandle *argp2 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54305   argp2 = (Dali::BaseHandle *)jarg2;
54306   if (!argp2) {
54307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54308     return ;
54309   }
54310   arg2 = *argp2;
54311   {
54312     try {
54313       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54314     } catch (std::out_of_range& e) {
54315       {
54316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54317       };
54318     } catch (std::exception& e) {
54319       {
54320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54321       };
54322     } catch (Dali::DaliException e) {
54323       {
54324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54325       };
54326     } catch (...) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54329       };
54330     }
54331   }
54332
54333 }
54334
54335
54336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54337   void * jresult ;
54338   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54339
54340   {
54341     try {
54342       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54343     } catch (std::out_of_range& e) {
54344       {
54345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54346       };
54347     } catch (std::exception& e) {
54348       {
54349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (Dali::DaliException e) {
54352       {
54353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54354       };
54355     } catch (...) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54358       };
54359     }
54360   }
54361
54362   jresult = (void *)result;
54363   return jresult;
54364 }
54365
54366
54367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54368   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54369
54370   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54371   {
54372     try {
54373       delete arg1;
54374     } catch (std::out_of_range& e) {
54375       {
54376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (std::exception& e) {
54379       {
54380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54381       };
54382     } catch (Dali::DaliException e) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54389       };
54390     }
54391   }
54392
54393 }
54394
54395
54396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54397   unsigned int jresult ;
54398   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54399   bool result;
54400
54401   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54402   {
54403     try {
54404       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54405     } catch (std::out_of_range& e) {
54406       {
54407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54408       };
54409     } catch (std::exception& e) {
54410       {
54411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54412       };
54413     } catch (Dali::DaliException e) {
54414       {
54415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54416       };
54417     } catch (...) {
54418       {
54419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54420       };
54421     }
54422   }
54423
54424   jresult = result;
54425   return jresult;
54426 }
54427
54428
54429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54430   unsigned long jresult ;
54431   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54432   std::size_t result;
54433
54434   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54435   {
54436     try {
54437       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54438     } catch (std::out_of_range& e) {
54439       {
54440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (std::exception& e) {
54443       {
54444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54445       };
54446     } catch (Dali::DaliException e) {
54447       {
54448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54449       };
54450     } catch (...) {
54451       {
54452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54453       };
54454     }
54455   }
54456
54457   jresult = (unsigned long)result;
54458   return jresult;
54459 }
54460
54461
54462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54463   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54464   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54465
54466   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54467   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54468   {
54469     try {
54470       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54471     } catch (std::out_of_range& e) {
54472       {
54473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54474       };
54475     } catch (std::exception& e) {
54476       {
54477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54478       };
54479     } catch (Dali::DaliException e) {
54480       {
54481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54482       };
54483     } catch (...) {
54484       {
54485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54486       };
54487     }
54488   }
54489
54490 }
54491
54492
54493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54494   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54495   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54496
54497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54498   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54499   {
54500     try {
54501       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54502     } catch (std::out_of_range& e) {
54503       {
54504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54505       };
54506     } catch (std::exception& e) {
54507       {
54508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54509       };
54510     } catch (Dali::DaliException e) {
54511       {
54512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54513       };
54514     } catch (...) {
54515       {
54516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54517       };
54518     }
54519   }
54520
54521 }
54522
54523
54524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54525   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54526   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54527
54528   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54529   arg2 = (Dali::RefObject *)jarg2;
54530   {
54531     try {
54532       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54533     } catch (std::out_of_range& e) {
54534       {
54535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54536       };
54537     } catch (std::exception& e) {
54538       {
54539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54540       };
54541     } catch (Dali::DaliException e) {
54542       {
54543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54544       };
54545     } catch (...) {
54546       {
54547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54548       };
54549     }
54550   }
54551
54552 }
54553
54554
54555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54556   void * jresult ;
54557   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54558
54559   {
54560     try {
54561       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (Dali::DaliException e) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54573       };
54574     } catch (...) {
54575       {
54576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54577       };
54578     }
54579   }
54580
54581   jresult = (void *)result;
54582   return jresult;
54583 }
54584
54585
54586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54587   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54588
54589   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54590   {
54591     try {
54592       delete arg1;
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54600       };
54601     } catch (Dali::DaliException e) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54604       };
54605     } catch (...) {
54606       {
54607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54608       };
54609     }
54610   }
54611
54612 }
54613
54614
54615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54616   unsigned int jresult ;
54617   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54618   bool result;
54619
54620   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54621   {
54622     try {
54623       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54624     } catch (std::out_of_range& e) {
54625       {
54626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54627       };
54628     } catch (std::exception& e) {
54629       {
54630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54631       };
54632     } catch (Dali::DaliException e) {
54633       {
54634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54639       };
54640     }
54641   }
54642
54643   jresult = result;
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54649   unsigned long jresult ;
54650   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54651   std::size_t result;
54652
54653   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54654   {
54655     try {
54656       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54657     } catch (std::out_of_range& e) {
54658       {
54659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54660       };
54661     } catch (std::exception& e) {
54662       {
54663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54664       };
54665     } catch (Dali::DaliException e) {
54666       {
54667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54668       };
54669     } catch (...) {
54670       {
54671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54672       };
54673     }
54674   }
54675
54676   jresult = (unsigned long)result;
54677   return jresult;
54678 }
54679
54680
54681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54682   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54683   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54684
54685   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54686   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54687   {
54688     try {
54689       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54690     } catch (std::out_of_range& e) {
54691       {
54692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54693       };
54694     } catch (std::exception& e) {
54695       {
54696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54697       };
54698     } catch (Dali::DaliException e) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54701       };
54702     } catch (...) {
54703       {
54704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54705       };
54706     }
54707   }
54708
54709 }
54710
54711
54712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54714   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54715
54716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54717   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54718   {
54719     try {
54720       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54721     } catch (std::out_of_range& e) {
54722       {
54723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54724       };
54725     } catch (std::exception& e) {
54726       {
54727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54728       };
54729     } catch (Dali::DaliException e) {
54730       {
54731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54736       };
54737     }
54738   }
54739
54740 }
54741
54742
54743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54744   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54745   Dali::PropertyNotification *arg2 = 0 ;
54746
54747   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54748   arg2 = (Dali::PropertyNotification *)jarg2;
54749   if (!arg2) {
54750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54751     return ;
54752   }
54753   {
54754     try {
54755       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54756     } catch (std::out_of_range& e) {
54757       {
54758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54759       };
54760     } catch (std::exception& e) {
54761       {
54762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54763       };
54764     } catch (Dali::DaliException e) {
54765       {
54766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54767       };
54768     } catch (...) {
54769       {
54770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54771       };
54772     }
54773   }
54774
54775 }
54776
54777
54778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54779   void * jresult ;
54780   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54781
54782   {
54783     try {
54784       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (Dali::DaliException e) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54796       };
54797     } catch (...) {
54798       {
54799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54800       };
54801     }
54802   }
54803
54804   jresult = (void *)result;
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54810   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54813   {
54814     try {
54815       delete arg1;
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54823       };
54824     } catch (Dali::DaliException e) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54827       };
54828     } catch (...) {
54829       {
54830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54831       };
54832     }
54833   }
54834
54835 }
54836
54837
54838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54839   unsigned int jresult ;
54840   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54841   bool result;
54842
54843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54844   {
54845     try {
54846       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54847     } catch (std::out_of_range& e) {
54848       {
54849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54850       };
54851     } catch (std::exception& e) {
54852       {
54853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54854       };
54855     } catch (Dali::DaliException e) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54858       };
54859     } catch (...) {
54860       {
54861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54862       };
54863     }
54864   }
54865
54866   jresult = result;
54867   return jresult;
54868 }
54869
54870
54871 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54872   unsigned long jresult ;
54873   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54874   std::size_t result;
54875
54876   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54877   {
54878     try {
54879       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54880     } catch (std::out_of_range& e) {
54881       {
54882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54883       };
54884     } catch (std::exception& e) {
54885       {
54886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54887       };
54888     } catch (Dali::DaliException e) {
54889       {
54890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54891       };
54892     } catch (...) {
54893       {
54894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54895       };
54896     }
54897   }
54898
54899   jresult = (unsigned long)result;
54900   return jresult;
54901 }
54902
54903
54904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54905   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54906   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54907
54908   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54909   arg2 = (void (*)(Dali::Image))jarg2;
54910   {
54911     try {
54912       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54920       };
54921     } catch (Dali::DaliException e) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54924       };
54925     } catch (...) {
54926       {
54927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54928       };
54929     }
54930   }
54931
54932 }
54933
54934
54935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54936   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54937   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54938
54939   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54940   arg2 = (void (*)(Dali::Image))jarg2;
54941   {
54942     try {
54943       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54951       };
54952     } catch (Dali::DaliException e) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54959       };
54960     }
54961   }
54962
54963 }
54964
54965
54966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54967   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54968   Dali::Image arg2 ;
54969   Dali::Image *argp2 ;
54970
54971   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54972   argp2 = (Dali::Image *)jarg2;
54973   if (!argp2) {
54974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54975     return ;
54976   }
54977   arg2 = *argp2;
54978   {
54979     try {
54980       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54996       };
54997     }
54998   }
54999
55000 }
55001
55002
55003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
55004   void * jresult ;
55005   Dali::Signal< void (Dali::Image) > *result = 0 ;
55006
55007   {
55008     try {
55009       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55010     } catch (std::out_of_range& e) {
55011       {
55012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55013       };
55014     } catch (std::exception& e) {
55015       {
55016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55017       };
55018     } catch (Dali::DaliException e) {
55019       {
55020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55021       };
55022     } catch (...) {
55023       {
55024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55025       };
55026     }
55027   }
55028
55029   jresult = (void *)result;
55030   return jresult;
55031 }
55032
55033
55034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55035   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55036
55037   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55038   {
55039     try {
55040       delete arg1;
55041     } catch (std::out_of_range& e) {
55042       {
55043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55044       };
55045     } catch (std::exception& e) {
55046       {
55047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55048       };
55049     } catch (Dali::DaliException e) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55052       };
55053     } catch (...) {
55054       {
55055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55056       };
55057     }
55058   }
55059
55060 }
55061
55062
55063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55064   void * jresult ;
55065   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55066
55067   {
55068     try {
55069       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55077       };
55078     } catch (Dali::DaliException e) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55081       };
55082     } catch (...) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55085       };
55086     }
55087   }
55088
55089   jresult = (void *)result;
55090   return jresult;
55091 }
55092
55093
55094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55095   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55096
55097   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55098   {
55099     try {
55100       delete arg1;
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55124   unsigned int jresult ;
55125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55126   bool result;
55127
55128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55129   {
55130     try {
55131       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);
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55139       };
55140     } catch (Dali::DaliException e) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55147       };
55148     }
55149   }
55150
55151   jresult = result;
55152   return jresult;
55153 }
55154
55155
55156 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55157   unsigned long jresult ;
55158   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55159   std::size_t result;
55160
55161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55162   {
55163     try {
55164       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);
55165     } catch (std::out_of_range& e) {
55166       {
55167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (std::exception& e) {
55170       {
55171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (Dali::DaliException e) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183
55184   jresult = (unsigned long)result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55190   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55191   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55192
55193   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55194   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55195   {
55196     try {
55197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55198     } catch (std::out_of_range& e) {
55199       {
55200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55201       };
55202     } catch (std::exception& e) {
55203       {
55204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55205       };
55206     } catch (Dali::DaliException e) {
55207       {
55208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55209       };
55210     } catch (...) {
55211       {
55212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55213       };
55214     }
55215   }
55216
55217 }
55218
55219
55220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55221   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55222   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55223
55224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55225   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55226   {
55227     try {
55228       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55229     } catch (std::out_of_range& e) {
55230       {
55231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55232       };
55233     } catch (std::exception& e) {
55234       {
55235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55236       };
55237     } catch (Dali::DaliException e) {
55238       {
55239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55240       };
55241     } catch (...) {
55242       {
55243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55244       };
55245     }
55246   }
55247
55248 }
55249
55250
55251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55252   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55253   Dali::Actor arg2 ;
55254   Dali::LongPressGesture *arg3 = 0 ;
55255   Dali::Actor *argp2 ;
55256
55257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55258   argp2 = (Dali::Actor *)jarg2;
55259   if (!argp2) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55261     return ;
55262   }
55263   arg2 = *argp2;
55264   arg3 = (Dali::LongPressGesture *)jarg3;
55265   if (!arg3) {
55266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55267     return ;
55268   }
55269   {
55270     try {
55271       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55272     } catch (std::out_of_range& e) {
55273       {
55274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55275       };
55276     } catch (std::exception& e) {
55277       {
55278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55279       };
55280     } catch (Dali::DaliException e) {
55281       {
55282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55287       };
55288     }
55289   }
55290
55291 }
55292
55293
55294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55295   void * jresult ;
55296   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55297
55298   {
55299     try {
55300       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55301     } catch (std::out_of_range& e) {
55302       {
55303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55304       };
55305     } catch (std::exception& e) {
55306       {
55307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55308       };
55309     } catch (Dali::DaliException e) {
55310       {
55311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55316       };
55317     }
55318   }
55319
55320   jresult = (void *)result;
55321   return jresult;
55322 }
55323
55324
55325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55326   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55327
55328   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55329   {
55330     try {
55331       delete arg1;
55332     } catch (std::out_of_range& e) {
55333       {
55334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55335       };
55336     } catch (std::exception& e) {
55337       {
55338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55339       };
55340     } catch (Dali::DaliException e) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55347       };
55348     }
55349   }
55350
55351 }
55352
55353
55354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55355   unsigned int jresult ;
55356   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55357   bool result;
55358
55359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55360   {
55361     try {
55362       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);
55363     } catch (std::out_of_range& e) {
55364       {
55365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55366       };
55367     } catch (std::exception& e) {
55368       {
55369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55370       };
55371     } catch (Dali::DaliException e) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55374       };
55375     } catch (...) {
55376       {
55377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55378       };
55379     }
55380   }
55381
55382   jresult = result;
55383   return jresult;
55384 }
55385
55386
55387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55388   unsigned long jresult ;
55389   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55390   std::size_t result;
55391
55392   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55393   {
55394     try {
55395       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);
55396     } catch (std::out_of_range& e) {
55397       {
55398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55399       };
55400     } catch (std::exception& e) {
55401       {
55402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55403       };
55404     } catch (Dali::DaliException e) {
55405       {
55406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55407       };
55408     } catch (...) {
55409       {
55410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55411       };
55412     }
55413   }
55414
55415   jresult = (unsigned long)result;
55416   return jresult;
55417 }
55418
55419
55420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55421   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55422   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55423
55424   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55425   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55426   {
55427     try {
55428       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55429     } catch (std::out_of_range& e) {
55430       {
55431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55432       };
55433     } catch (std::exception& e) {
55434       {
55435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55436       };
55437     } catch (Dali::DaliException e) {
55438       {
55439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55440       };
55441     } catch (...) {
55442       {
55443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55444       };
55445     }
55446   }
55447
55448 }
55449
55450
55451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55452   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55453   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55454
55455   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55456   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55457   {
55458     try {
55459       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55460     } catch (std::out_of_range& e) {
55461       {
55462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55463       };
55464     } catch (std::exception& e) {
55465       {
55466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55467       };
55468     } catch (Dali::DaliException e) {
55469       {
55470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55471       };
55472     } catch (...) {
55473       {
55474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55475       };
55476     }
55477   }
55478
55479 }
55480
55481
55482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55483   unsigned int jresult ;
55484   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55485   Dali::Actor arg2 ;
55486   Dali::TouchData *arg3 = 0 ;
55487   Dali::Actor *argp2 ;
55488   bool result;
55489
55490   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55491   argp2 = (Dali::Actor *)jarg2;
55492   if (!argp2) {
55493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55494     return 0;
55495   }
55496   arg2 = *argp2;
55497   arg3 = (Dali::TouchData *)jarg3;
55498   if (!arg3) {
55499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55500     return 0;
55501   }
55502   {
55503     try {
55504       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55505     } catch (std::out_of_range& e) {
55506       {
55507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55508       };
55509     } catch (std::exception& e) {
55510       {
55511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (Dali::DaliException e) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55516       };
55517     } catch (...) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55520       };
55521     }
55522   }
55523
55524   jresult = result;
55525   return jresult;
55526 }
55527
55528
55529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55530   void * jresult ;
55531   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55532
55533   {
55534     try {
55535       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55536     } catch (std::out_of_range& e) {
55537       {
55538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55539       };
55540     } catch (std::exception& e) {
55541       {
55542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55543       };
55544     } catch (Dali::DaliException e) {
55545       {
55546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55547       };
55548     } catch (...) {
55549       {
55550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55551       };
55552     }
55553   }
55554
55555   jresult = (void *)result;
55556   return jresult;
55557 }
55558
55559
55560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55561   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55564   {
55565     try {
55566       delete arg1;
55567     } catch (std::out_of_range& e) {
55568       {
55569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55570       };
55571     } catch (std::exception& e) {
55572       {
55573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55574       };
55575     } catch (Dali::DaliException e) {
55576       {
55577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55582       };
55583     }
55584   }
55585
55586 }
55587
55588
55589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55590   unsigned int jresult ;
55591   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55592   bool result;
55593
55594   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55595   {
55596     try {
55597       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);
55598     } catch (std::out_of_range& e) {
55599       {
55600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55601       };
55602     } catch (std::exception& e) {
55603       {
55604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55605       };
55606     } catch (Dali::DaliException e) {
55607       {
55608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55613       };
55614     }
55615   }
55616
55617   jresult = result;
55618   return jresult;
55619 }
55620
55621
55622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55623   unsigned long jresult ;
55624   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55625   std::size_t result;
55626
55627   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55628   {
55629     try {
55630       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);
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55638       };
55639     } catch (Dali::DaliException e) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55642       };
55643     } catch (...) {
55644       {
55645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55646       };
55647     }
55648   }
55649
55650   jresult = (unsigned long)result;
55651   return jresult;
55652 }
55653
55654
55655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55656   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55657   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55658
55659   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55660   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55661   {
55662     try {
55663       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55664     } catch (std::out_of_range& e) {
55665       {
55666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55667       };
55668     } catch (std::exception& e) {
55669       {
55670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55671       };
55672     } catch (Dali::DaliException e) {
55673       {
55674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55675       };
55676     } catch (...) {
55677       {
55678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55679       };
55680     }
55681   }
55682
55683 }
55684
55685
55686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55687   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55688   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55689
55690   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55691   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55692   {
55693     try {
55694       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55695     } catch (std::out_of_range& e) {
55696       {
55697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55698       };
55699     } catch (std::exception& e) {
55700       {
55701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55702       };
55703     } catch (Dali::DaliException e) {
55704       {
55705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55706       };
55707     } catch (...) {
55708       {
55709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55710       };
55711     }
55712   }
55713
55714 }
55715
55716
55717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55718   unsigned int jresult ;
55719   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55720   Dali::Actor arg2 ;
55721   Dali::HoverEvent *arg3 = 0 ;
55722   Dali::Actor *argp2 ;
55723   bool result;
55724
55725   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55726   argp2 = (Dali::Actor *)jarg2;
55727   if (!argp2) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55729     return 0;
55730   }
55731   arg2 = *argp2;
55732   arg3 = (Dali::HoverEvent *)jarg3;
55733   if (!arg3) {
55734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55735     return 0;
55736   }
55737   {
55738     try {
55739       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55740     } catch (std::out_of_range& e) {
55741       {
55742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (std::exception& e) {
55745       {
55746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (Dali::DaliException e) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55751       };
55752     } catch (...) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55755       };
55756     }
55757   }
55758
55759   jresult = result;
55760   return jresult;
55761 }
55762
55763
55764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55765   void * jresult ;
55766   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55767
55768   {
55769     try {
55770       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55771     } catch (std::out_of_range& e) {
55772       {
55773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (std::exception& e) {
55776       {
55777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (Dali::DaliException e) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55782       };
55783     } catch (...) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55786       };
55787     }
55788   }
55789
55790   jresult = (void *)result;
55791   return jresult;
55792 }
55793
55794
55795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55796   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55799   {
55800     try {
55801       delete arg1;
55802     } catch (std::out_of_range& e) {
55803       {
55804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55805       };
55806     } catch (std::exception& e) {
55807       {
55808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55809       };
55810     } catch (Dali::DaliException e) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55817       };
55818     }
55819   }
55820
55821 }
55822
55823
55824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55825   unsigned int jresult ;
55826   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55827   bool result;
55828
55829   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55830   {
55831     try {
55832       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);
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55840       };
55841     } catch (Dali::DaliException e) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55848       };
55849     }
55850   }
55851
55852   jresult = result;
55853   return jresult;
55854 }
55855
55856
55857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55858   unsigned long jresult ;
55859   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55860   std::size_t result;
55861
55862   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55863   {
55864     try {
55865       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);
55866     } catch (std::out_of_range& e) {
55867       {
55868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55869       };
55870     } catch (std::exception& e) {
55871       {
55872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55873       };
55874     } catch (Dali::DaliException e) {
55875       {
55876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55877       };
55878     } catch (...) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55881       };
55882     }
55883   }
55884
55885   jresult = (unsigned long)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55891   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55892   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55893
55894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55895   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55896   {
55897     try {
55898       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55906       };
55907     } catch (Dali::DaliException e) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55910       };
55911     } catch (...) {
55912       {
55913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55914       };
55915     }
55916   }
55917
55918 }
55919
55920
55921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55922   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55923   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55924
55925   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55926   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55927   {
55928     try {
55929       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55945       };
55946     }
55947   }
55948
55949 }
55950
55951
55952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55953   unsigned int jresult ;
55954   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55955   Dali::Actor arg2 ;
55956   Dali::WheelEvent *arg3 = 0 ;
55957   Dali::Actor *argp2 ;
55958   bool result;
55959
55960   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55961   argp2 = (Dali::Actor *)jarg2;
55962   if (!argp2) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55964     return 0;
55965   }
55966   arg2 = *argp2;
55967   arg3 = (Dali::WheelEvent *)jarg3;
55968   if (!arg3) {
55969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55970     return 0;
55971   }
55972   {
55973     try {
55974       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55975     } catch (std::out_of_range& e) {
55976       {
55977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (std::exception& e) {
55980       {
55981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (Dali::DaliException e) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55986       };
55987     } catch (...) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55990       };
55991     }
55992   }
55993
55994   jresult = result;
55995   return jresult;
55996 }
55997
55998
55999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
56000   void * jresult ;
56001   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
56002
56003   {
56004     try {
56005       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56006     } catch (std::out_of_range& e) {
56007       {
56008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (std::exception& e) {
56011       {
56012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (Dali::DaliException e) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56017       };
56018     } catch (...) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56021       };
56022     }
56023   }
56024
56025   jresult = (void *)result;
56026   return jresult;
56027 }
56028
56029
56030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56031   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56032
56033   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56034   {
56035     try {
56036       delete arg1;
56037     } catch (std::out_of_range& e) {
56038       {
56039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56040       };
56041     } catch (std::exception& e) {
56042       {
56043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56044       };
56045     } catch (Dali::DaliException e) {
56046       {
56047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56052       };
56053     }
56054   }
56055
56056 }
56057
56058
56059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56060   unsigned int jresult ;
56061   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56062   bool result;
56063
56064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56065   {
56066     try {
56067       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56068     } catch (std::out_of_range& e) {
56069       {
56070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56071       };
56072     } catch (std::exception& e) {
56073       {
56074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56075       };
56076     } catch (Dali::DaliException e) {
56077       {
56078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56079       };
56080     } catch (...) {
56081       {
56082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56083       };
56084     }
56085   }
56086
56087   jresult = result;
56088   return jresult;
56089 }
56090
56091
56092 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56093   unsigned long jresult ;
56094   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56095   std::size_t result;
56096
56097   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56098   {
56099     try {
56100       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (Dali::DaliException e) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56112       };
56113     } catch (...) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56116       };
56117     }
56118   }
56119
56120   jresult = (unsigned long)result;
56121   return jresult;
56122 }
56123
56124
56125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56126   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56127   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56128
56129   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56130   arg2 = (void (*)(Dali::Actor))jarg2;
56131   {
56132     try {
56133       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56134     } catch (std::out_of_range& e) {
56135       {
56136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56137       };
56138     } catch (std::exception& e) {
56139       {
56140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56141       };
56142     } catch (Dali::DaliException e) {
56143       {
56144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56149       };
56150     }
56151   }
56152
56153 }
56154
56155
56156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56157   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56158   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56159
56160   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56161   arg2 = (void (*)(Dali::Actor))jarg2;
56162   {
56163     try {
56164       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56165     } catch (std::out_of_range& e) {
56166       {
56167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56168       };
56169     } catch (std::exception& e) {
56170       {
56171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56172       };
56173     } catch (Dali::DaliException e) {
56174       {
56175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56180       };
56181     }
56182   }
56183
56184 }
56185
56186
56187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56188   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56189   Dali::Actor arg2 ;
56190   Dali::Actor *argp2 ;
56191
56192   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56193   argp2 = (Dali::Actor *)jarg2;
56194   if (!argp2) {
56195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56196     return ;
56197   }
56198   arg2 = *argp2;
56199   {
56200     try {
56201       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56202     } catch (std::out_of_range& e) {
56203       {
56204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56205       };
56206     } catch (std::exception& e) {
56207       {
56208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56209       };
56210     } catch (Dali::DaliException e) {
56211       {
56212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56213       };
56214     } catch (...) {
56215       {
56216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56217       };
56218     }
56219   }
56220
56221 }
56222
56223
56224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56225   void * jresult ;
56226   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56227
56228   {
56229     try {
56230       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (Dali::DaliException e) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56242       };
56243     } catch (...) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56246       };
56247     }
56248   }
56249
56250   jresult = (void *)result;
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56256   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56257
56258   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56259   {
56260     try {
56261       delete arg1;
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56269       };
56270     } catch (Dali::DaliException e) {
56271       {
56272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56273       };
56274     } catch (...) {
56275       {
56276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56277       };
56278     }
56279   }
56280
56281 }
56282
56283
56284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56285   unsigned int jresult ;
56286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56287   bool result;
56288
56289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56290   {
56291     try {
56292       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56300       };
56301     } catch (Dali::DaliException e) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56304       };
56305     } catch (...) {
56306       {
56307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56308       };
56309     }
56310   }
56311
56312   jresult = result;
56313   return jresult;
56314 }
56315
56316
56317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56318   unsigned long jresult ;
56319   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56320   std::size_t result;
56321
56322   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56323   {
56324     try {
56325       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56326     } catch (std::out_of_range& e) {
56327       {
56328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56329       };
56330     } catch (std::exception& e) {
56331       {
56332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (Dali::DaliException e) {
56335       {
56336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344
56345   jresult = (unsigned long)result;
56346   return jresult;
56347 }
56348
56349
56350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56351   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56352   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56353
56354   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56355   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56356   {
56357     try {
56358       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56359     } catch (std::out_of_range& e) {
56360       {
56361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56362       };
56363     } catch (std::exception& e) {
56364       {
56365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56366       };
56367     } catch (Dali::DaliException e) {
56368       {
56369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56370       };
56371     } catch (...) {
56372       {
56373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56374       };
56375     }
56376   }
56377
56378 }
56379
56380
56381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56382   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56383   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56384
56385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56386   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56387   {
56388     try {
56389       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56390     } catch (std::out_of_range& e) {
56391       {
56392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56393       };
56394     } catch (std::exception& e) {
56395       {
56396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56397       };
56398     } catch (Dali::DaliException e) {
56399       {
56400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56401       };
56402     } catch (...) {
56403       {
56404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56405       };
56406     }
56407   }
56408
56409 }
56410
56411
56412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56413   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56414   Dali::KeyEvent *arg2 = 0 ;
56415
56416   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56417   arg2 = (Dali::KeyEvent *)jarg2;
56418   if (!arg2) {
56419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56420     return ;
56421   }
56422   {
56423     try {
56424       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56425     } catch (std::out_of_range& e) {
56426       {
56427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56428       };
56429     } catch (std::exception& e) {
56430       {
56431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56432       };
56433     } catch (Dali::DaliException e) {
56434       {
56435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56436       };
56437     } catch (...) {
56438       {
56439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56440       };
56441     }
56442   }
56443
56444 }
56445
56446
56447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56448   void * jresult ;
56449   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56450
56451   {
56452     try {
56453       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (Dali::DaliException e) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472
56473   jresult = (void *)result;
56474   return jresult;
56475 }
56476
56477
56478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56479   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56480
56481   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56482   {
56483     try {
56484       delete arg1;
56485     } catch (std::out_of_range& e) {
56486       {
56487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (std::exception& e) {
56490       {
56491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56492       };
56493     } catch (Dali::DaliException e) {
56494       {
56495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56496       };
56497     } catch (...) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56500       };
56501     }
56502   }
56503
56504 }
56505
56506
56507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56508   unsigned int jresult ;
56509   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56510   bool result;
56511
56512   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56513   {
56514     try {
56515       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56523       };
56524     } catch (Dali::DaliException e) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56531       };
56532     }
56533   }
56534
56535   jresult = result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56541   unsigned long jresult ;
56542   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56543   std::size_t result;
56544
56545   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56546   {
56547     try {
56548       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (Dali::DaliException e) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56560       };
56561     } catch (...) {
56562       {
56563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56564       };
56565     }
56566   }
56567
56568   jresult = (unsigned long)result;
56569   return jresult;
56570 }
56571
56572
56573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56574   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56575   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56576
56577   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56578   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56579   {
56580     try {
56581       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56582     } catch (std::out_of_range& e) {
56583       {
56584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56585       };
56586     } catch (std::exception& e) {
56587       {
56588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56589       };
56590     } catch (Dali::DaliException e) {
56591       {
56592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56593       };
56594     } catch (...) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56597       };
56598     }
56599   }
56600
56601 }
56602
56603
56604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56605   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56606   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56607
56608   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56609   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56610   {
56611     try {
56612       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56620       };
56621     } catch (Dali::DaliException e) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56624       };
56625     } catch (...) {
56626       {
56627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56628       };
56629     }
56630   }
56631
56632 }
56633
56634
56635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56636   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56637   Dali::TouchData *arg2 = 0 ;
56638
56639   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56640   arg2 = (Dali::TouchData *)jarg2;
56641   if (!arg2) {
56642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56643     return ;
56644   }
56645   {
56646     try {
56647       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56648     } catch (std::out_of_range& e) {
56649       {
56650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56651       };
56652     } catch (std::exception& e) {
56653       {
56654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56655       };
56656     } catch (Dali::DaliException e) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56659       };
56660     } catch (...) {
56661       {
56662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56663       };
56664     }
56665   }
56666
56667 }
56668
56669
56670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56671   void * jresult ;
56672   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56673
56674   {
56675     try {
56676       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (Dali::DaliException e) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56688       };
56689     } catch (...) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56692       };
56693     }
56694   }
56695
56696   jresult = (void *)result;
56697   return jresult;
56698 }
56699
56700
56701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56702   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56703
56704   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56705   {
56706     try {
56707       delete arg1;
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56715       };
56716     } catch (Dali::DaliException e) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56719       };
56720     } catch (...) {
56721       {
56722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56723       };
56724     }
56725   }
56726
56727 }
56728
56729
56730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56731   unsigned int jresult ;
56732   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56733   bool result;
56734
56735   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56736   {
56737     try {
56738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56739     } catch (std::out_of_range& e) {
56740       {
56741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56742       };
56743     } catch (std::exception& e) {
56744       {
56745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (Dali::DaliException e) {
56748       {
56749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757
56758   jresult = result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56764   unsigned long jresult ;
56765   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56766   std::size_t result;
56767
56768   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56769   {
56770     try {
56771       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (Dali::DaliException e) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56783       };
56784     } catch (...) {
56785       {
56786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56787       };
56788     }
56789   }
56790
56791   jresult = (unsigned long)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56797   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56798   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56799
56800   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56801   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56802   {
56803     try {
56804       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56805     } catch (std::out_of_range& e) {
56806       {
56807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56808       };
56809     } catch (std::exception& e) {
56810       {
56811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56812       };
56813     } catch (Dali::DaliException e) {
56814       {
56815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56816       };
56817     } catch (...) {
56818       {
56819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56820       };
56821     }
56822   }
56823
56824 }
56825
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56828   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56829   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56830
56831   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56832   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56833   {
56834     try {
56835       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56836     } catch (std::out_of_range& e) {
56837       {
56838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56839       };
56840     } catch (std::exception& e) {
56841       {
56842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56843       };
56844     } catch (Dali::DaliException e) {
56845       {
56846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56847       };
56848     } catch (...) {
56849       {
56850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56851       };
56852     }
56853   }
56854
56855 }
56856
56857
56858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56859   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56860   Dali::WheelEvent *arg2 = 0 ;
56861
56862   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56863   arg2 = (Dali::WheelEvent *)jarg2;
56864   if (!arg2) {
56865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56866     return ;
56867   }
56868   {
56869     try {
56870       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56871     } catch (std::out_of_range& e) {
56872       {
56873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56874       };
56875     } catch (std::exception& e) {
56876       {
56877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56878       };
56879     } catch (Dali::DaliException e) {
56880       {
56881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56886       };
56887     }
56888   }
56889
56890 }
56891
56892
56893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56894   void * jresult ;
56895   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56896
56897   {
56898     try {
56899       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (Dali::DaliException e) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56911       };
56912     } catch (...) {
56913       {
56914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56915       };
56916     }
56917   }
56918
56919   jresult = (void *)result;
56920   return jresult;
56921 }
56922
56923
56924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56925   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56926
56927   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56928   {
56929     try {
56930       delete arg1;
56931     } catch (std::out_of_range& e) {
56932       {
56933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56934       };
56935     } catch (std::exception& e) {
56936       {
56937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56938       };
56939     } catch (Dali::DaliException e) {
56940       {
56941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56942       };
56943     } catch (...) {
56944       {
56945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56946       };
56947     }
56948   }
56949
56950 }
56951
56952
56953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56954   void * jresult ;
56955   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56956
56957   {
56958     try {
56959       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56960     } catch (std::out_of_range& e) {
56961       {
56962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (std::exception& e) {
56965       {
56966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56967       };
56968     } catch (Dali::DaliException e) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56971       };
56972     } catch (...) {
56973       {
56974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56975       };
56976     }
56977   }
56978
56979   jresult = (void *)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56985   void * jresult ;
56986   Dali::Radian arg1 ;
56987   Dali::Radian arg2 ;
56988   Dali::Radian *argp1 ;
56989   Dali::Radian *argp2 ;
56990   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56991
56992   argp1 = (Dali::Radian *)jarg1;
56993   if (!argp1) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56995     return 0;
56996   }
56997   arg1 = *argp1;
56998   argp2 = (Dali::Radian *)jarg2;
56999   if (!argp2) {
57000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
57001     return 0;
57002   }
57003   arg2 = *argp2;
57004   {
57005     try {
57006       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57007     } catch (std::out_of_range& e) {
57008       {
57009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (std::exception& e) {
57012       {
57013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57014       };
57015     } catch (Dali::DaliException e) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57018       };
57019     } catch (...) {
57020       {
57021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57022       };
57023     }
57024   }
57025
57026   jresult = (void *)result;
57027   return jresult;
57028 }
57029
57030
57031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57032   void * jresult ;
57033   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57034   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57035
57036   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57037   if (!arg1) {
57038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57039     return 0;
57040   }
57041   {
57042     try {
57043       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57044     } catch (std::out_of_range& e) {
57045       {
57046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57047       };
57048     } catch (std::exception& e) {
57049       {
57050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57051       };
57052     } catch (Dali::DaliException e) {
57053       {
57054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57055       };
57056     } catch (...) {
57057       {
57058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57059       };
57060     }
57061   }
57062
57063   jresult = (void *)result;
57064   return jresult;
57065 }
57066
57067
57068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57069   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57070   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57071
57072   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57073   arg2 = (Dali::Radian *)jarg2;
57074   if (arg1) (arg1)->first = *arg2;
57075 }
57076
57077
57078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57079   void * jresult ;
57080   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57081   Dali::Radian *result = 0 ;
57082
57083   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57084   result = (Dali::Radian *)& ((arg1)->first);
57085   jresult = (void *)result;
57086   return jresult;
57087 }
57088
57089
57090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57091   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57092   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57093
57094   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57095   arg2 = (Dali::Radian *)jarg2;
57096   if (arg1) (arg1)->second = *arg2;
57097 }
57098
57099
57100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57101   void * jresult ;
57102   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57103   Dali::Radian *result = 0 ;
57104
57105   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57106   result = (Dali::Radian *)& ((arg1)->second);
57107   jresult = (void *)result;
57108   return jresult;
57109 }
57110
57111
57112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57113   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57114
57115   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57116   {
57117     try {
57118       delete arg1;
57119     } catch (std::out_of_range& e) {
57120       {
57121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57122       };
57123     } catch (std::exception& e) {
57124       {
57125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57126       };
57127     } catch (Dali::DaliException e) {
57128       {
57129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57130       };
57131     } catch (...) {
57132       {
57133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57134       };
57135     }
57136   }
57137
57138 }
57139
57140
57141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57142   unsigned int jresult ;
57143   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57144   bool result;
57145
57146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57147   {
57148     try {
57149       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);
57150     } catch (std::out_of_range& e) {
57151       {
57152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57153       };
57154     } catch (std::exception& e) {
57155       {
57156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57157       };
57158     } catch (Dali::DaliException e) {
57159       {
57160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57161       };
57162     } catch (...) {
57163       {
57164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57165       };
57166     }
57167   }
57168
57169   jresult = result;
57170   return jresult;
57171 }
57172
57173
57174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57175   unsigned long jresult ;
57176   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57177   std::size_t result;
57178
57179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57180   {
57181     try {
57182       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);
57183     } catch (std::out_of_range& e) {
57184       {
57185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57186       };
57187     } catch (std::exception& e) {
57188       {
57189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (Dali::DaliException e) {
57192       {
57193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57194       };
57195     } catch (...) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57198       };
57199     }
57200   }
57201
57202   jresult = (unsigned long)result;
57203   return jresult;
57204 }
57205
57206
57207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57208   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57209   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57210
57211   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57212   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57213   {
57214     try {
57215       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57216     } catch (std::out_of_range& e) {
57217       {
57218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57219       };
57220     } catch (std::exception& e) {
57221       {
57222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57223       };
57224     } catch (Dali::DaliException e) {
57225       {
57226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57227       };
57228     } catch (...) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57231       };
57232     }
57233   }
57234
57235 }
57236
57237
57238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57239   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57240   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57241
57242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57243   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57244   {
57245     try {
57246       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57247     } catch (std::out_of_range& e) {
57248       {
57249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57250       };
57251     } catch (std::exception& e) {
57252       {
57253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57254       };
57255     } catch (Dali::DaliException e) {
57256       {
57257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57258       };
57259     } catch (...) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57262       };
57263     }
57264   }
57265
57266 }
57267
57268
57269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57270   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57271   Dali::Actor arg2 ;
57272   Dali::PanGesture *arg3 = 0 ;
57273   Dali::Actor *argp2 ;
57274
57275   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57276   argp2 = (Dali::Actor *)jarg2;
57277   if (!argp2) {
57278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57279     return ;
57280   }
57281   arg2 = *argp2;
57282   arg3 = (Dali::PanGesture *)jarg3;
57283   if (!arg3) {
57284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57285     return ;
57286   }
57287   {
57288     try {
57289       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57297       };
57298     } catch (Dali::DaliException e) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57301       };
57302     } catch (...) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57305       };
57306     }
57307   }
57308
57309 }
57310
57311
57312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57313   void * jresult ;
57314   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57315
57316   {
57317     try {
57318       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57319     } catch (std::out_of_range& e) {
57320       {
57321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (std::exception& e) {
57324       {
57325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57326       };
57327     } catch (Dali::DaliException e) {
57328       {
57329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57330       };
57331     } catch (...) {
57332       {
57333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57334       };
57335     }
57336   }
57337
57338   jresult = (void *)result;
57339   return jresult;
57340 }
57341
57342
57343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57344   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57345
57346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57347   {
57348     try {
57349       delete arg1;
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57357       };
57358     } catch (Dali::DaliException e) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57361       };
57362     } catch (...) {
57363       {
57364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57365       };
57366     }
57367   }
57368
57369 }
57370
57371
57372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57373   unsigned int jresult ;
57374   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57375   bool result;
57376
57377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57378   {
57379     try {
57380       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);
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57388       };
57389     } catch (Dali::DaliException e) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57392       };
57393     } catch (...) {
57394       {
57395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57396       };
57397     }
57398   }
57399
57400   jresult = result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57406   unsigned long jresult ;
57407   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57408   std::size_t result;
57409
57410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57411   {
57412     try {
57413       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);
57414     } catch (std::out_of_range& e) {
57415       {
57416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57417       };
57418     } catch (std::exception& e) {
57419       {
57420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (Dali::DaliException e) {
57423       {
57424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57429       };
57430     }
57431   }
57432
57433   jresult = (unsigned long)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57439   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57440   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57441
57442   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57443   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57444   {
57445     try {
57446       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57447     } catch (std::out_of_range& e) {
57448       {
57449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57450       };
57451     } catch (std::exception& e) {
57452       {
57453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57454       };
57455     } catch (Dali::DaliException e) {
57456       {
57457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57458       };
57459     } catch (...) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57462       };
57463     }
57464   }
57465
57466 }
57467
57468
57469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57470   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57471   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57472
57473   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57474   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57475   {
57476     try {
57477       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57478     } catch (std::out_of_range& e) {
57479       {
57480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57481       };
57482     } catch (std::exception& e) {
57483       {
57484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57485       };
57486     } catch (Dali::DaliException e) {
57487       {
57488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57489       };
57490     } catch (...) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57493       };
57494     }
57495   }
57496
57497 }
57498
57499
57500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57501   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57502   Dali::Actor arg2 ;
57503   Dali::PinchGesture *arg3 = 0 ;
57504   Dali::Actor *argp2 ;
57505
57506   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57507   argp2 = (Dali::Actor *)jarg2;
57508   if (!argp2) {
57509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57510     return ;
57511   }
57512   arg2 = *argp2;
57513   arg3 = (Dali::PinchGesture *)jarg3;
57514   if (!arg3) {
57515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57516     return ;
57517   }
57518   {
57519     try {
57520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57521     } catch (std::out_of_range& e) {
57522       {
57523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57524       };
57525     } catch (std::exception& e) {
57526       {
57527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57528       };
57529     } catch (Dali::DaliException e) {
57530       {
57531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57532       };
57533     } catch (...) {
57534       {
57535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57536       };
57537     }
57538   }
57539
57540 }
57541
57542
57543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57544   void * jresult ;
57545   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57546
57547   {
57548     try {
57549       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (Dali::DaliException e) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57561       };
57562     } catch (...) {
57563       {
57564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57565       };
57566     }
57567   }
57568
57569   jresult = (void *)result;
57570   return jresult;
57571 }
57572
57573
57574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57575   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57576
57577   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57578   {
57579     try {
57580       delete arg1;
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57588       };
57589     } catch (Dali::DaliException e) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57596       };
57597     }
57598   }
57599
57600 }
57601
57602
57603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57604   unsigned int jresult ;
57605   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57606   bool result;
57607
57608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57609   {
57610     try {
57611       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);
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (Dali::DaliException e) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57623       };
57624     } catch (...) {
57625       {
57626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57627       };
57628     }
57629   }
57630
57631   jresult = result;
57632   return jresult;
57633 }
57634
57635
57636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57637   unsigned long jresult ;
57638   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57639   std::size_t result;
57640
57641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57642   {
57643     try {
57644       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);
57645     } catch (std::out_of_range& e) {
57646       {
57647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57648       };
57649     } catch (std::exception& e) {
57650       {
57651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57652       };
57653     } catch (Dali::DaliException e) {
57654       {
57655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57656       };
57657     } catch (...) {
57658       {
57659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57660       };
57661     }
57662   }
57663
57664   jresult = (unsigned long)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57670   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57671   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57672
57673   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57674   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57675   {
57676     try {
57677       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57678     } catch (std::out_of_range& e) {
57679       {
57680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57681       };
57682     } catch (std::exception& e) {
57683       {
57684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57685       };
57686     } catch (Dali::DaliException e) {
57687       {
57688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57689       };
57690     } catch (...) {
57691       {
57692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57693       };
57694     }
57695   }
57696
57697 }
57698
57699
57700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57701   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57702   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57703
57704   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57705   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57706   {
57707     try {
57708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57709     } catch (std::out_of_range& e) {
57710       {
57711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57712       };
57713     } catch (std::exception& e) {
57714       {
57715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57716       };
57717     } catch (Dali::DaliException e) {
57718       {
57719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57720       };
57721     } catch (...) {
57722       {
57723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57724       };
57725     }
57726   }
57727
57728 }
57729
57730
57731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57732   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57733   Dali::Actor arg2 ;
57734   Dali::TapGesture *arg3 = 0 ;
57735   Dali::Actor *argp2 ;
57736
57737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57738   argp2 = (Dali::Actor *)jarg2;
57739   if (!argp2) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57741     return ;
57742   }
57743   arg2 = *argp2;
57744   arg3 = (Dali::TapGesture *)jarg3;
57745   if (!arg3) {
57746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57747     return ;
57748   }
57749   {
57750     try {
57751       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57752     } catch (std::out_of_range& e) {
57753       {
57754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57755       };
57756     } catch (std::exception& e) {
57757       {
57758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57759       };
57760     } catch (Dali::DaliException e) {
57761       {
57762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57763       };
57764     } catch (...) {
57765       {
57766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57767       };
57768     }
57769   }
57770
57771 }
57772
57773
57774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57775   void * jresult ;
57776   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57777
57778   {
57779     try {
57780       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57781     } catch (std::out_of_range& e) {
57782       {
57783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57784       };
57785     } catch (std::exception& e) {
57786       {
57787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57788       };
57789     } catch (Dali::DaliException e) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57792       };
57793     } catch (...) {
57794       {
57795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57796       };
57797     }
57798   }
57799
57800   jresult = (void *)result;
57801   return jresult;
57802 }
57803
57804
57805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57806   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57807
57808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57809   {
57810     try {
57811       delete arg1;
57812     } catch (std::out_of_range& e) {
57813       {
57814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (std::exception& e) {
57817       {
57818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (Dali::DaliException e) {
57821       {
57822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57823       };
57824     } catch (...) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57827       };
57828     }
57829   }
57830
57831 }
57832
57833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57834   unsigned int jresult ;
57835   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57836   bool result;
57837
57838   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57839   {
57840     try {
57841       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57849       };
57850     } catch (Dali::DaliException e) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57853       };
57854     } catch (...) {
57855       {
57856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57857       };
57858     }
57859   }
57860
57861   jresult = result;
57862   return jresult;
57863 }
57864
57865
57866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57867   unsigned long jresult ;
57868   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57869   std::size_t result;
57870
57871   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57872   {
57873     try {
57874       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57875     } catch (std::out_of_range& e) {
57876       {
57877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57878       };
57879     } catch (std::exception& e) {
57880       {
57881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (Dali::DaliException e) {
57884       {
57885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57886       };
57887     } catch (...) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57890       };
57891     }
57892   }
57893
57894   jresult = (unsigned long)result;
57895   return jresult;
57896 }
57897
57898
57899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57900   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57901   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57902
57903   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57904   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57905   {
57906     try {
57907       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57908     } catch (std::out_of_range& e) {
57909       {
57910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57911       };
57912     } catch (std::exception& e) {
57913       {
57914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57915       };
57916     } catch (Dali::DaliException e) {
57917       {
57918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57919       };
57920     } catch (...) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57923       };
57924     }
57925   }
57926
57927 }
57928
57929
57930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57931   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57932   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57933
57934   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57935   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57936   {
57937     try {
57938       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57946       };
57947     } catch (Dali::DaliException e) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57950       };
57951     } catch (...) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57954       };
57955     }
57956   }
57957
57958 }
57959
57960
57961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57962   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57963   Dali::ResourceImage arg2 ;
57964   Dali::ResourceImage *argp2 ;
57965
57966   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57967   argp2 = (Dali::ResourceImage *)jarg2;
57968   if (!argp2) {
57969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57970     return ;
57971   }
57972   arg2 = *argp2;
57973   {
57974     try {
57975       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57976     } catch (std::out_of_range& e) {
57977       {
57978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57979       };
57980     } catch (std::exception& e) {
57981       {
57982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57983       };
57984     } catch (Dali::DaliException e) {
57985       {
57986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57987       };
57988     } catch (...) {
57989       {
57990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57991       };
57992     }
57993   }
57994
57995 }
57996
57997
57998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57999   void * jresult ;
58000   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
58001
58002   {
58003     try {
58004       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
58005     } catch (std::out_of_range& e) {
58006       {
58007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (std::exception& e) {
58010       {
58011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58012       };
58013     } catch (Dali::DaliException e) {
58014       {
58015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58016       };
58017     } catch (...) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58020       };
58021     }
58022   }
58023
58024   jresult = (void *)result;
58025   return jresult;
58026 }
58027
58028
58029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58030   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58031
58032   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58033   {
58034     try {
58035       delete arg1;
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58043       };
58044     } catch (Dali::DaliException e) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58051       };
58052     }
58053   }
58054
58055 }
58056
58057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58058   unsigned int jresult ;
58059   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58060   bool result = false;
58061
58062   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58063   {
58064     try {
58065       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);
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58075   }
58076   jresult = result;
58077   return jresult;
58078 }
58079
58080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58081   unsigned long jresult ;
58082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58083   std::size_t result = 0;
58084
58085   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58086   {
58087     try {
58088       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);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58098   }
58099   jresult = (unsigned long)result;
58100   return jresult;
58101 }
58102
58103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58104   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58105   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58106
58107   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58108   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58109   {
58110     try {
58111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58112     } catch (std::out_of_range& e) {
58113       {
58114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (std::exception& e) {
58117       {
58118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58121   }
58122 }
58123
58124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58125   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58126   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58127
58128   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58129   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58130   {
58131     try {
58132       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58140       };
58141     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58142   }
58143 }
58144
58145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58146   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58147   Dali::Actor arg2 ;
58148   //bool arg3 ;
58149   Dali::LayoutDirection::Type arg4 ;
58150   Dali::Actor *argp2 ;
58151
58152   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58153   argp2 = (Dali::Actor *)jarg2;
58154   if (!argp2) {
58155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58156     return ;
58157   }
58158   arg2 = *argp2;
58159   //arg3 = jarg3 ? true : false;
58160   arg4 = (Dali::LayoutDirection::Type)jarg4;
58161   {
58162     try {
58163       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58164     } catch (std::out_of_range& e) {
58165       {
58166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58167       };
58168     } catch (std::exception& e) {
58169       {
58170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58171       };
58172     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58173   }
58174 }
58175
58176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58177   void * jresult ;
58178   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58179
58180   {
58181     try {
58182       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58183     } catch (std::out_of_range& e) {
58184       {
58185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (std::exception& e) {
58188       {
58189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58190       };
58191     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58192   }
58193   jresult = (void *)result;
58194   return jresult;
58195 }
58196
58197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58198   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58199
58200   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58201   {
58202     try {
58203       delete arg1;
58204     } catch (std::out_of_range& e) {
58205       {
58206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58207       };
58208     } catch (std::exception& e) {
58209       {
58210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58211       };
58212     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58213   }
58214 }
58215
58216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58217   unsigned int jresult ;
58218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58219   bool result;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58222   {
58223     try {
58224       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);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (Dali::DaliException e) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58240       };
58241     }
58242   }
58243
58244   jresult = result;
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58250   unsigned long jresult ;
58251   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58252   std::size_t result;
58253
58254   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58255   {
58256     try {
58257       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);
58258     } catch (std::out_of_range& e) {
58259       {
58260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (std::exception& e) {
58263       {
58264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58265       };
58266     } catch (Dali::DaliException e) {
58267       {
58268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58269       };
58270     } catch (...) {
58271       {
58272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58273       };
58274     }
58275   }
58276
58277   jresult = (unsigned long)result;
58278   return jresult;
58279 }
58280
58281
58282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58283   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58284   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58285
58286   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58287   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58288   {
58289     try {
58290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58298       };
58299     } catch (Dali::DaliException e) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58302       };
58303     } catch (...) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58306       };
58307     }
58308   }
58309
58310 }
58311
58312
58313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58314   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58315   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58316
58317   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58318   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58319   {
58320     try {
58321       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58322     } catch (std::out_of_range& e) {
58323       {
58324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58325       };
58326     } catch (std::exception& e) {
58327       {
58328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (Dali::DaliException e) {
58331       {
58332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58337       };
58338     }
58339   }
58340
58341 }
58342
58343
58344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58345   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58346   Dali::Actor arg2 ;
58347   bool arg3 ;
58348   Dali::DevelActor::VisibilityChange::Type arg4 ;
58349   Dali::Actor *argp2 ;
58350
58351   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58352   argp2 = (Dali::Actor *)jarg2;
58353   if (!argp2) {
58354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58355     return ;
58356   }
58357   arg2 = *argp2;
58358   arg3 = jarg3 ? true : false;
58359   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58360   {
58361     try {
58362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58378       };
58379     }
58380   }
58381
58382 }
58383
58384
58385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58386   void * jresult ;
58387   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58388
58389   {
58390     try {
58391       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58392     } catch (std::out_of_range& e) {
58393       {
58394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58395       };
58396     } catch (std::exception& e) {
58397       {
58398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (Dali::DaliException e) {
58401       {
58402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58403       };
58404     } catch (...) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58407       };
58408     }
58409   }
58410
58411   jresult = (void *)result;
58412   return jresult;
58413 }
58414
58415
58416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58417   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58418
58419   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58420   {
58421     try {
58422       delete arg1;
58423     } catch (std::out_of_range& e) {
58424       {
58425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58426       };
58427     } catch (std::exception& e) {
58428       {
58429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58430       };
58431     } catch (Dali::DaliException e) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58434       };
58435     } catch (...) {
58436       {
58437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58438       };
58439     }
58440   }
58441
58442 }
58443
58444
58445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58446   void * jresult ;
58447   Dali::Timer *result = 0 ;
58448
58449   {
58450     try {
58451       result = (Dali::Timer *)new Dali::Timer();
58452     } catch (std::out_of_range& e) {
58453       {
58454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58455       };
58456     } catch (std::exception& e) {
58457       {
58458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58459       };
58460     } catch (Dali::DaliException e) {
58461       {
58462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58467       };
58468     }
58469   }
58470
58471   jresult = (void *)result;
58472   return jresult;
58473 }
58474
58475
58476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58477   void * jresult ;
58478   unsigned int arg1 ;
58479   Dali::Timer result;
58480
58481   arg1 = (unsigned int)jarg1;
58482   {
58483     try {
58484       result = Dali::Timer::New(arg1);
58485     } catch (std::out_of_range& e) {
58486       {
58487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58488       };
58489     } catch (std::exception& e) {
58490       {
58491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58492       };
58493     } catch (Dali::DaliException e) {
58494       {
58495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58500       };
58501     }
58502   }
58503
58504   jresult = new Dali::Timer((const Dali::Timer &)result);
58505   return jresult;
58506 }
58507
58508
58509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58510   void * jresult ;
58511   Dali::Timer *arg1 = 0 ;
58512   Dali::Timer *result = 0 ;
58513
58514   arg1 = (Dali::Timer *)jarg1;
58515   if (!arg1) {
58516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58517     return 0;
58518   }
58519   {
58520     try {
58521       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58522     } catch (std::out_of_range& e) {
58523       {
58524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58525       };
58526     } catch (std::exception& e) {
58527       {
58528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58529       };
58530     } catch (Dali::DaliException e) {
58531       {
58532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58533       };
58534     } catch (...) {
58535       {
58536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58537       };
58538     }
58539   }
58540
58541   jresult = (void *)result;
58542   return jresult;
58543 }
58544
58545
58546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58547   void * jresult ;
58548   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58549   Dali::Timer *arg2 = 0 ;
58550   Dali::Timer *result = 0 ;
58551
58552   arg1 = (Dali::Timer *)jarg1;
58553   arg2 = (Dali::Timer *)jarg2;
58554   if (!arg2) {
58555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58556     return 0;
58557   }
58558   {
58559     try {
58560       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (Dali::DaliException e) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58572       };
58573     } catch (...) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58576       };
58577     }
58578   }
58579
58580   jresult = (void *)result;
58581   return jresult;
58582 }
58583
58584
58585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58586   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58587
58588   arg1 = (Dali::Timer *)jarg1;
58589   {
58590     try {
58591       delete arg1;
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58607       };
58608     }
58609   }
58610
58611 }
58612
58613
58614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58615   void * jresult ;
58616   Dali::BaseHandle arg1 ;
58617   Dali::BaseHandle *argp1 ;
58618   Dali::Timer result;
58619
58620   argp1 = (Dali::BaseHandle *)jarg1;
58621   if (!argp1) {
58622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58623     return 0;
58624   }
58625   arg1 = *argp1;
58626   {
58627     try {
58628       result = Dali::Timer::DownCast(arg1);
58629     } catch (std::out_of_range& e) {
58630       {
58631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (std::exception& e) {
58634       {
58635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58636       };
58637     } catch (Dali::DaliException e) {
58638       {
58639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58640       };
58641     } catch (...) {
58642       {
58643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58644       };
58645     }
58646   }
58647
58648   jresult = new Dali::Timer((const Dali::Timer &)result);
58649   return jresult;
58650 }
58651
58652
58653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58654   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58655
58656   arg1 = (Dali::Timer *)jarg1;
58657   {
58658     try {
58659       (arg1)->Start();
58660     } catch (std::out_of_range& e) {
58661       {
58662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58663       };
58664     } catch (std::exception& e) {
58665       {
58666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58667       };
58668     } catch (Dali::DaliException e) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58671       };
58672     } catch (...) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58675       };
58676     }
58677   }
58678
58679 }
58680
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58683   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58684
58685   arg1 = (Dali::Timer *)jarg1;
58686   {
58687     try {
58688       (arg1)->Stop();
58689     } catch (std::out_of_range& e) {
58690       {
58691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58692       };
58693     } catch (std::exception& e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58696       };
58697     } catch (Dali::DaliException e) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58700       };
58701     } catch (...) {
58702       {
58703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58704       };
58705     }
58706   }
58707
58708 }
58709
58710
58711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58712   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58713   unsigned int arg2 ;
58714
58715   arg1 = (Dali::Timer *)jarg1;
58716   arg2 = (unsigned int)jarg2;
58717   {
58718     try {
58719       (arg1)->SetInterval(arg2);
58720     } catch (std::out_of_range& e) {
58721       {
58722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58723       };
58724     } catch (std::exception& e) {
58725       {
58726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58727       };
58728     } catch (Dali::DaliException e) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58731       };
58732     } catch (...) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58735       };
58736     }
58737   }
58738
58739 }
58740
58741
58742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58743   unsigned int jresult ;
58744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58745   unsigned int result;
58746
58747   arg1 = (Dali::Timer *)jarg1;
58748   {
58749     try {
58750       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58751     } catch (std::out_of_range& e) {
58752       {
58753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (std::exception& e) {
58756       {
58757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (Dali::DaliException e) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58762       };
58763     } catch (...) {
58764       {
58765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58766       };
58767     }
58768   }
58769
58770   jresult = result;
58771   return jresult;
58772 }
58773
58774
58775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58776   unsigned int jresult ;
58777   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58778   bool result;
58779
58780   arg1 = (Dali::Timer *)jarg1;
58781   {
58782     try {
58783       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58784     } catch (std::out_of_range& e) {
58785       {
58786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58787       };
58788     } catch (std::exception& e) {
58789       {
58790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (Dali::DaliException e) {
58793       {
58794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58795       };
58796     } catch (...) {
58797       {
58798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58799       };
58800     }
58801   }
58802
58803   jresult = result;
58804   return jresult;
58805 }
58806
58807
58808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58809   void * jresult ;
58810   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58811   Dali::Timer::TimerSignalType *result = 0 ;
58812
58813   arg1 = (Dali::Timer *)jarg1;
58814   {
58815     try {
58816       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58817     } catch (std::out_of_range& e) {
58818       {
58819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58820       };
58821     } catch (std::exception& e) {
58822       {
58823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (Dali::DaliException e) {
58826       {
58827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835
58836   jresult = (void *)result;
58837   return jresult;
58838 }
58839
58840
58841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58842   unsigned int jresult ;
58843   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58844   bool result;
58845
58846   arg1 = (Dali::Signal< bool () > *)jarg1;
58847   {
58848     try {
58849       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58850     } catch (std::out_of_range& e) {
58851       {
58852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58853       };
58854     } catch (std::exception& e) {
58855       {
58856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (Dali::DaliException e) {
58859       {
58860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58861       };
58862     } catch (...) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58865       };
58866     }
58867   }
58868
58869   jresult = result;
58870   return jresult;
58871 }
58872
58873
58874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58875   unsigned long jresult ;
58876   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58877   std::size_t result;
58878
58879   arg1 = (Dali::Signal< bool () > *)jarg1;
58880   {
58881     try {
58882       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58883     } catch (std::out_of_range& e) {
58884       {
58885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (std::exception& e) {
58888       {
58889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (Dali::DaliException e) {
58892       {
58893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58898       };
58899     }
58900   }
58901
58902   jresult = (unsigned long)result;
58903   return jresult;
58904 }
58905
58906
58907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58908   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58909   bool (*arg2)() = (bool (*)()) 0 ;
58910
58911   arg1 = (Dali::Signal< bool () > *)jarg1;
58912   arg2 = (bool (*)())jarg2;
58913   {
58914     try {
58915       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58923       };
58924     } catch (Dali::DaliException e) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58927       };
58928     } catch (...) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58931       };
58932     }
58933   }
58934
58935 }
58936
58937
58938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58939   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58940   bool (*arg2)() = (bool (*)()) 0 ;
58941
58942   arg1 = (Dali::Signal< bool () > *)jarg1;
58943   arg2 = (bool (*)())jarg2;
58944   {
58945     try {
58946       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58947     } catch (std::out_of_range& e) {
58948       {
58949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58950       };
58951     } catch (std::exception& e) {
58952       {
58953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58954       };
58955     } catch (Dali::DaliException e) {
58956       {
58957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58962       };
58963     }
58964   }
58965
58966 }
58967
58968
58969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58970   unsigned int jresult ;
58971   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58972   bool result;
58973
58974   arg1 = (Dali::Signal< bool () > *)jarg1;
58975   {
58976     try {
58977       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58978     } catch (std::out_of_range& e) {
58979       {
58980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58981       };
58982     } catch (std::exception& e) {
58983       {
58984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58985       };
58986     } catch (Dali::DaliException e) {
58987       {
58988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58989       };
58990     } catch (...) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58993       };
58994     }
58995   }
58996
58997   jresult = result;
58998   return jresult;
58999 }
59000
59001
59002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59003   void * jresult ;
59004   Dali::Signal< bool () > *result = 0 ;
59005
59006   {
59007     try {
59008       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59009     } catch (std::out_of_range& e) {
59010       {
59011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (std::exception& e) {
59014       {
59015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (Dali::DaliException e) {
59018       {
59019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59024       };
59025     }
59026   }
59027
59028   jresult = (void *)result;
59029   return jresult;
59030 }
59031
59032
59033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59034   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59035
59036   arg1 = (Dali::Signal< bool () > *)jarg1;
59037   {
59038     try {
59039       delete arg1;
59040     } catch (std::out_of_range& e) {
59041       {
59042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59043       };
59044     } catch (std::exception& e) {
59045       {
59046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59047       };
59048     } catch (Dali::DaliException e) {
59049       {
59050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59051       };
59052     } catch (...) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59055       };
59056     }
59057   }
59058
59059 }
59060
59061
59062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59063   int jresult ;
59064   int result;
59065
59066   {
59067     try {
59068       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59069     } catch (std::out_of_range& e) {
59070       {
59071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (std::exception& e) {
59074       {
59075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59076       };
59077     } catch (Dali::DaliException e) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59080       };
59081     } catch (...) {
59082       {
59083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59084       };
59085     }
59086   }
59087
59088   jresult = (int)result;
59089   return jresult;
59090 }
59091
59092
59093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59094   int jresult ;
59095   int result;
59096
59097   {
59098     try {
59099       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59100     } catch (std::out_of_range& e) {
59101       {
59102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (std::exception& e) {
59105       {
59106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59107       };
59108     } catch (Dali::DaliException e) {
59109       {
59110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59111       };
59112     } catch (...) {
59113       {
59114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59115       };
59116     }
59117   }
59118
59119   jresult = (int)result;
59120   return jresult;
59121 }
59122
59123
59124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59125   int jresult ;
59126   int result;
59127
59128   {
59129     try {
59130       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59131     } catch (std::out_of_range& e) {
59132       {
59133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59134       };
59135     } catch (std::exception& e) {
59136       {
59137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59138       };
59139     } catch (Dali::DaliException e) {
59140       {
59141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59142       };
59143     } catch (...) {
59144       {
59145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59146       };
59147     }
59148   }
59149
59150   jresult = (int)result;
59151   return jresult;
59152 }
59153
59154
59155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59156   int jresult ;
59157   int result;
59158
59159   {
59160     try {
59161       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59162     } catch (std::out_of_range& e) {
59163       {
59164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59165       };
59166     } catch (std::exception& e) {
59167       {
59168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59169       };
59170     } catch (Dali::DaliException e) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59177       };
59178     }
59179   }
59180
59181   jresult = (int)result;
59182   return jresult;
59183 }
59184
59185
59186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59187   int jresult ;
59188   int result;
59189
59190   {
59191     try {
59192       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59193     } catch (std::out_of_range& e) {
59194       {
59195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (std::exception& e) {
59198       {
59199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (Dali::DaliException e) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59204       };
59205     } catch (...) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59208       };
59209     }
59210   }
59211
59212   jresult = (int)result;
59213   return jresult;
59214 }
59215
59216
59217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59218   int jresult ;
59219   int result;
59220
59221   {
59222     try {
59223       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59224     } catch (std::out_of_range& e) {
59225       {
59226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59227       };
59228     } catch (std::exception& e) {
59229       {
59230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (Dali::DaliException e) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59235       };
59236     } catch (...) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59239       };
59240     }
59241   }
59242
59243   jresult = (int)result;
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59249   int jresult ;
59250   int result;
59251
59252   {
59253     try {
59254       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (Dali::DaliException e) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59266       };
59267     } catch (...) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59270       };
59271     }
59272   }
59273
59274   jresult = (int)result;
59275   return jresult;
59276 }
59277
59278
59279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59280   int jresult ;
59281   int result;
59282
59283   {
59284     try {
59285       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59286     } catch (std::out_of_range& e) {
59287       {
59288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59289       };
59290     } catch (std::exception& e) {
59291       {
59292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (Dali::DaliException e) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59297       };
59298     } catch (...) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59301       };
59302     }
59303   }
59304
59305   jresult = (int)result;
59306   return jresult;
59307 }
59308
59309
59310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59311   int jresult ;
59312   int result;
59313
59314   {
59315     try {
59316       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (Dali::DaliException e) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59328       };
59329     } catch (...) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59332       };
59333     }
59334   }
59335
59336   jresult = (int)result;
59337   return jresult;
59338 }
59339
59340
59341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59342   int jresult ;
59343   int result;
59344
59345   {
59346     try {
59347       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59348     } catch (std::out_of_range& e) {
59349       {
59350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (std::exception& e) {
59353       {
59354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (Dali::DaliException e) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59359       };
59360     } catch (...) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59363       };
59364     }
59365   }
59366
59367   jresult = (int)result;
59368   return jresult;
59369 }
59370
59371
59372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59373   int jresult ;
59374   int result;
59375
59376   {
59377     try {
59378       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59379     } catch (std::out_of_range& e) {
59380       {
59381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (std::exception& e) {
59384       {
59385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (Dali::DaliException e) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397
59398   jresult = (int)result;
59399   return jresult;
59400 }
59401
59402
59403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59404   int jresult ;
59405   int result;
59406
59407   {
59408     try {
59409       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59410     } catch (std::out_of_range& e) {
59411       {
59412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (std::exception& e) {
59415       {
59416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (Dali::DaliException e) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59421       };
59422     } catch (...) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59425       };
59426     }
59427   }
59428
59429   jresult = (int)result;
59430   return jresult;
59431 }
59432
59433
59434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59435   int jresult ;
59436   int result;
59437
59438   {
59439     try {
59440       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59441     } catch (std::out_of_range& e) {
59442       {
59443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (std::exception& e) {
59446       {
59447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (Dali::DaliException e) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59452       };
59453     } catch (...) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59456       };
59457     }
59458   }
59459
59460   jresult = (int)result;
59461   return jresult;
59462 }
59463
59464
59465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59466   int jresult ;
59467   int result;
59468
59469   {
59470     try {
59471       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59472     } catch (std::out_of_range& e) {
59473       {
59474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (std::exception& e) {
59477       {
59478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (Dali::DaliException e) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59483       };
59484     } catch (...) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59487       };
59488     }
59489   }
59490
59491   jresult = (int)result;
59492   return jresult;
59493 }
59494
59495
59496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59497   int jresult ;
59498   int result;
59499
59500   {
59501     try {
59502       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59503     } catch (std::out_of_range& e) {
59504       {
59505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59506       };
59507     } catch (std::exception& e) {
59508       {
59509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (Dali::DaliException e) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59514       };
59515     } catch (...) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59518       };
59519     }
59520   }
59521
59522   jresult = (int)result;
59523   return jresult;
59524 }
59525
59526
59527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59528   int jresult ;
59529   int result;
59530
59531   {
59532     try {
59533       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59534     } catch (std::out_of_range& e) {
59535       {
59536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (std::exception& e) {
59539       {
59540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (Dali::DaliException e) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59545       };
59546     } catch (...) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59549       };
59550     }
59551   }
59552
59553   jresult = (int)result;
59554   return jresult;
59555 }
59556
59557
59558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59559   int jresult ;
59560   int result;
59561
59562   {
59563     try {
59564       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59565     } catch (std::out_of_range& e) {
59566       {
59567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (std::exception& e) {
59570       {
59571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (Dali::DaliException e) {
59574       {
59575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59576       };
59577     } catch (...) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59580       };
59581     }
59582   }
59583
59584   jresult = (int)result;
59585   return jresult;
59586 }
59587
59588
59589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59590   int jresult ;
59591   int result;
59592
59593   {
59594     try {
59595       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59596     } catch (std::out_of_range& e) {
59597       {
59598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59599       };
59600     } catch (std::exception& e) {
59601       {
59602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (Dali::DaliException e) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59607       };
59608     } catch (...) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59611       };
59612     }
59613   }
59614
59615   jresult = (int)result;
59616   return jresult;
59617 }
59618
59619
59620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59621   int jresult ;
59622   int result;
59623
59624   {
59625     try {
59626       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59627     } catch (std::out_of_range& e) {
59628       {
59629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (std::exception& e) {
59632       {
59633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (Dali::DaliException e) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59638       };
59639     } catch (...) {
59640       {
59641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59642       };
59643     }
59644   }
59645
59646   jresult = (int)result;
59647   return jresult;
59648 }
59649
59650
59651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59652   int jresult ;
59653   int result;
59654
59655   {
59656     try {
59657       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59658     } catch (std::out_of_range& e) {
59659       {
59660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (std::exception& e) {
59663       {
59664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (Dali::DaliException e) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676
59677   jresult = (int)result;
59678   return jresult;
59679 }
59680
59681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59682   int jresult ;
59683   int result;
59684
59685   {
59686     try {
59687       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59688     } catch (std::out_of_range& e) {
59689       {
59690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (std::exception& e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (Dali::DaliException e) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706
59707   jresult = (int)result;
59708   return jresult;
59709 }
59710
59711
59712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59713   int jresult ;
59714   int result;
59715   {
59716     try
59717     {
59718       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59719     } catch (std::out_of_range& e) {
59720       {
59721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (std::exception& e) {
59724       {
59725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59726       };
59727     } catch (Dali::DaliException e) {
59728       {
59729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59730       };
59731     } catch (...) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59734       };
59735     }
59736   }
59737
59738   jresult = (int)result;
59739   return jresult;
59740 }
59741
59742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59743   int jresult ;
59744   int result;
59745   {
59746     try
59747     {
59748       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (Dali::DaliException e) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59760       };
59761     } catch (...) {
59762       {
59763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59764       };
59765     }
59766   }
59767
59768   jresult = (int)result;
59769   return jresult;
59770 }
59771
59772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59773   int jresult ;
59774   int result;
59775   {
59776     try
59777     {
59778       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59779     } catch (std::out_of_range& e) {
59780       {
59781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59782       };
59783     } catch (std::exception& e) {
59784       {
59785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59786       };
59787     } catch (Dali::DaliException e) {
59788       {
59789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59794       };
59795     }
59796   }
59797
59798   jresult = (int)result;
59799   return jresult;
59800 }
59801
59802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59803   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59804 }
59805
59806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59807   int jresult ;
59808   int result;
59809   {
59810     try
59811     {
59812       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59813     } catch (std::out_of_range& e) {
59814       {
59815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59816       };
59817     } catch (std::exception& e) {
59818       {
59819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59820       };
59821     } catch (Dali::DaliException e) {
59822       {
59823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59824       };
59825     } catch (...) {
59826       {
59827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59828       };
59829     }
59830   }
59831
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59837   int jresult ;
59838   int result;
59839   {
59840     try
59841     {
59842       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59843     } catch (std::out_of_range& e) {
59844       {
59845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59846       };
59847     } catch (std::exception& e) {
59848       {
59849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (Dali::DaliException e) {
59852       {
59853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59854       };
59855     } catch (...) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59858       };
59859     }
59860   }
59861
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (Dali::DaliException e) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59884       };
59885     } catch (...) {
59886       {
59887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59888       };
59889     }
59890   }
59891
59892   jresult = (int)result;
59893   return jresult;
59894 }
59895
59896
59897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59898   int jresult ;
59899   int result;
59900
59901   {
59902     try {
59903       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59904     } catch (std::out_of_range& e) {
59905       {
59906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (std::exception& e) {
59909       {
59910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (Dali::DaliException e) {
59913       {
59914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59919       };
59920     }
59921   }
59922
59923   jresult = (int)result;
59924   return jresult;
59925 }
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59928   int jresult ;
59929   int result;
59930   {
59931     try
59932     {
59933       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (...) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59945       };
59946     }
59947   }
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59953   int jresult ;
59954   int result;
59955   {
59956     try
59957     {
59958       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59959     } catch (std::out_of_range& e) {
59960       {
59961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59962       };
59963     } catch (std::exception& e) {
59964       {
59965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59966       };
59967     } catch (...) {
59968       {
59969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59970       };
59971     }
59972   }
59973   jresult = (int)result;
59974   return jresult;
59975 }
59976
59977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59978   int jresult ;
59979   int result;
59980   {
59981     try
59982     {
59983       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (...) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59995       };
59996     }
59997   }
59998   jresult = (int)result;
59999   return jresult;
60000 }
60001
60002
60003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60004   int jresult ;
60005   int result;
60006   {
60007     try
60008     {
60009       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60010     } catch (std::out_of_range& e) {
60011       {
60012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60013       };
60014     } catch (std::exception& e) {
60015       {
60016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60017       };
60018     } catch (...) {
60019       {
60020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60021       };
60022     }
60023   }
60024   jresult = (int)result;
60025   return jresult;
60026 }
60027
60028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60029   int jresult ;
60030   int result;
60031   {
60032     try
60033     {
60034       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60035     } catch (std::out_of_range& e) {
60036       {
60037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (std::exception& e) {
60040       {
60041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60042       };
60043     } catch (...) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60046       };
60047     }
60048   }
60049   jresult = (int)result;
60050   return jresult;
60051 }
60052
60053
60054
60055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60056   int jresult ;
60057   int result;
60058
60059   {
60060     try {
60061       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60062     } catch (std::out_of_range& e) {
60063       {
60064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (std::exception& e) {
60067       {
60068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (Dali::DaliException e) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080
60081   jresult = (int)result;
60082   return jresult;
60083 }
60084
60085
60086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60087   int jresult ;
60088   int result;
60089
60090   {
60091     try {
60092       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111
60112   jresult = (int)result;
60113   return jresult;
60114 }
60115
60116
60117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60118   int jresult ;
60119   int result;
60120
60121   {
60122     try {
60123       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (Dali::DaliException e) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60139       };
60140     }
60141   }
60142
60143   jresult = (int)result;
60144   return jresult;
60145 }
60146
60147
60148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60149   int jresult ;
60150   int result;
60151
60152   {
60153     try {
60154       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60155     } catch (std::out_of_range& e) {
60156       {
60157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60158       };
60159     } catch (std::exception& e) {
60160       {
60161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60162       };
60163     } catch (Dali::DaliException e) {
60164       {
60165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60166       };
60167     } catch (...) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60170       };
60171     }
60172   }
60173
60174   jresult = (int)result;
60175   return jresult;
60176 }
60177
60178
60179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60180   int jresult ;
60181   int result;
60182
60183   {
60184     try {
60185       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60186     } catch (std::out_of_range& e) {
60187       {
60188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60189       };
60190     } catch (std::exception& e) {
60191       {
60192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60193       };
60194     } catch (Dali::DaliException e) {
60195       {
60196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60197       };
60198     } catch (...) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60201       };
60202     }
60203   }
60204
60205   jresult = (int)result;
60206   return jresult;
60207 }
60208
60209
60210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60211   int jresult ;
60212   int result;
60213
60214   {
60215     try {
60216       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60217     } catch (std::out_of_range& e) {
60218       {
60219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (std::exception& e) {
60222       {
60223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60224       };
60225     } catch (Dali::DaliException e) {
60226       {
60227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60228       };
60229     } catch (...) {
60230       {
60231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60232       };
60233     }
60234   }
60235
60236   jresult = (int)result;
60237   return jresult;
60238 }
60239
60240
60241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60242   int jresult ;
60243   int result;
60244
60245   {
60246     try {
60247       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60248     } catch (std::out_of_range& e) {
60249       {
60250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60251       };
60252     } catch (std::exception& e) {
60253       {
60254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60255       };
60256     } catch (Dali::DaliException e) {
60257       {
60258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60259       };
60260     } catch (...) {
60261       {
60262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60263       };
60264     }
60265   }
60266
60267   jresult = (int)result;
60268   return jresult;
60269 }
60270
60271 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60272   int jresult ;
60273   int result;
60274
60275   {
60276     try {
60277       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60278     } catch (std::out_of_range& e) {
60279       {
60280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60281       };
60282     } catch (std::exception& e) {
60283       {
60284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60285       };
60286     } catch (...) {
60287       {
60288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60289       };
60290     }
60291   }
60292   jresult = (int)result;
60293   return jresult;
60294 }
60295
60296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60297   int jresult ;
60298   int result;
60299
60300   {
60301     try {
60302       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (Dali::DaliException e) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321
60322   jresult = (int)result;
60323   return jresult;
60324 }
60325
60326
60327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60328   int jresult ;
60329   int result;
60330
60331   {
60332     try {
60333       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60334     } catch (std::out_of_range& e) {
60335       {
60336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (std::exception& e) {
60339       {
60340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (Dali::DaliException e) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60345       };
60346     } catch (...) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60349       };
60350     }
60351   }
60352
60353   jresult = (int)result;
60354   return jresult;
60355 }
60356
60357
60358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60359   int jresult ;
60360   int result;
60361
60362   {
60363     try {
60364       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (Dali::DaliException e) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60376       };
60377     } catch (...) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60380       };
60381     }
60382   }
60383
60384   jresult = (int)result;
60385   return jresult;
60386 }
60387
60388
60389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60390   int jresult ;
60391   int result;
60392
60393   {
60394     try {
60395       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (Dali::DaliException e) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60411       };
60412     }
60413   }
60414
60415   jresult = (int)result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60421   int jresult ;
60422   int result;
60423
60424   {
60425     try {
60426       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (Dali::DaliException e) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445
60446   jresult = (int)result;
60447   return jresult;
60448 }
60449
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60452   int jresult ;
60453   int result;
60454
60455   {
60456     try {
60457       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (Dali::DaliException e) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60473       };
60474     }
60475   }
60476
60477   jresult = (int)result;
60478   return jresult;
60479 }
60480
60481
60482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60483   int jresult ;
60484   int result;
60485
60486   {
60487     try {
60488       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (Dali::DaliException e) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60504       };
60505     }
60506   }
60507
60508   jresult = (int)result;
60509   return jresult;
60510 }
60511
60512
60513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60514   int jresult ;
60515   int result;
60516
60517   {
60518     try {
60519       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60520     } catch (std::out_of_range& e) {
60521       {
60522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (std::exception& e) {
60525       {
60526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (Dali::DaliException e) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60531       };
60532     } catch (...) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60535       };
60536     }
60537   }
60538
60539   jresult = (int)result;
60540   return jresult;
60541 }
60542
60543
60544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60545   int jresult ;
60546   int result;
60547
60548   {
60549     try {
60550       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60551     } catch (std::out_of_range& e) {
60552       {
60553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (std::exception& e) {
60556       {
60557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (Dali::DaliException e) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569
60570   jresult = (int)result;
60571   return jresult;
60572 }
60573
60574
60575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60576   int jresult ;
60577   int result;
60578
60579   {
60580     try {
60581       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60582     } catch (std::out_of_range& e) {
60583       {
60584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (std::exception& e) {
60587       {
60588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (Dali::DaliException e) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60593       };
60594     } catch (...) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60597       };
60598     }
60599   }
60600
60601   jresult = (int)result;
60602   return jresult;
60603 }
60604
60605
60606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60607   int jresult ;
60608   int result;
60609
60610   {
60611     try {
60612       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60613     } catch (std::out_of_range& e) {
60614       {
60615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (std::exception& e) {
60618       {
60619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (Dali::DaliException e) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60624       };
60625     } catch (...) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60628       };
60629     }
60630   }
60631
60632   jresult = (int)result;
60633   return jresult;
60634 }
60635
60636
60637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60638   int jresult ;
60639   int result;
60640
60641   {
60642     try {
60643       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60644     } catch (std::out_of_range& e) {
60645       {
60646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (std::exception& e) {
60649       {
60650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (Dali::DaliException e) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60655       };
60656     } catch (...) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60659       };
60660     }
60661   }
60662
60663   jresult = (int)result;
60664   return jresult;
60665 }
60666
60667
60668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60669   int jresult ;
60670   int result;
60671
60672   {
60673     try {
60674       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (Dali::DaliException e) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60686       };
60687     } catch (...) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60690       };
60691     }
60692   }
60693
60694   jresult = (int)result;
60695   return jresult;
60696 }
60697
60698
60699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60700   int jresult ;
60701   int result;
60702
60703   {
60704     try {
60705       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60706     } catch (std::out_of_range& e) {
60707       {
60708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (std::exception& e) {
60711       {
60712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (Dali::DaliException e) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60717       };
60718     } catch (...) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60721       };
60722     }
60723   }
60724
60725   jresult = (int)result;
60726   return jresult;
60727 }
60728
60729
60730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60731   int jresult ;
60732   int result;
60733
60734   {
60735     try {
60736       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60737     } catch (std::out_of_range& e) {
60738       {
60739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (std::exception& e) {
60742       {
60743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (Dali::DaliException e) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60748       };
60749     } catch (...) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60752       };
60753     }
60754   }
60755
60756   jresult = (int)result;
60757   return jresult;
60758 }
60759
60760
60761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60762   int jresult ;
60763   int result;
60764
60765   {
60766     try {
60767       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (Dali::DaliException e) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60779       };
60780     } catch (...) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60783       };
60784     }
60785   }
60786
60787   jresult = (int)result;
60788   return jresult;
60789 }
60790
60791
60792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60793   int jresult ;
60794   int result;
60795
60796   {
60797     try {
60798       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60799     } catch (std::out_of_range& e) {
60800       {
60801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (std::exception& e) {
60804       {
60805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (Dali::DaliException e) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60810       };
60811     } catch (...) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60814       };
60815     }
60816   }
60817
60818   jresult = (int)result;
60819   return jresult;
60820 }
60821
60822
60823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60824   int jresult ;
60825   int result;
60826
60827   {
60828     try {
60829       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (Dali::DaliException e) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60845       };
60846     }
60847   }
60848
60849   jresult = (int)result;
60850   return jresult;
60851 }
60852
60853
60854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60855   int jresult ;
60856   int result;
60857
60858   {
60859     try {
60860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60861     } catch (std::out_of_range& e) {
60862       {
60863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (std::exception& e) {
60866       {
60867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (Dali::DaliException e) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60872       };
60873     } catch (...) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60876       };
60877     }
60878   }
60879
60880   jresult = (int)result;
60881   return jresult;
60882 }
60883
60884
60885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60886   int jresult ;
60887   int result;
60888
60889   {
60890     try {
60891       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60892     } catch (std::out_of_range& e) {
60893       {
60894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (std::exception& e) {
60897       {
60898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (Dali::DaliException e) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60903       };
60904     } catch (...) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60907       };
60908     }
60909   }
60910
60911   jresult = (int)result;
60912   return jresult;
60913 }
60914
60915
60916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60917   int jresult ;
60918   int result;
60919
60920   {
60921     try {
60922       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60923     } catch (std::out_of_range& e) {
60924       {
60925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (std::exception& e) {
60928       {
60929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (Dali::DaliException e) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941
60942   jresult = (int)result;
60943   return jresult;
60944 }
60945
60946
60947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60948   int jresult ;
60949   int result;
60950
60951   {
60952     try {
60953       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60954     } catch (std::out_of_range& e) {
60955       {
60956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (std::exception& e) {
60959       {
60960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (Dali::DaliException e) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60965       };
60966     } catch (...) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60969       };
60970     }
60971   }
60972
60973   jresult = (int)result;
60974   return jresult;
60975 }
60976
60977
60978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60979   int jresult ;
60980   int result;
60981
60982   {
60983     try {
60984       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60985     } catch (std::out_of_range& e) {
60986       {
60987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (std::exception& e) {
60990       {
60991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (Dali::DaliException e) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61000       };
61001     }
61002   }
61003
61004   jresult = (int)result;
61005   return jresult;
61006 }
61007
61008
61009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61010   int jresult ;
61011   int result;
61012
61013   {
61014     try {
61015       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61016     } catch (std::out_of_range& e) {
61017       {
61018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (std::exception& e) {
61021       {
61022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (Dali::DaliException e) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61031       };
61032     }
61033   }
61034
61035   jresult = (int)result;
61036   return jresult;
61037 }
61038
61039
61040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61041   int jresult ;
61042   int result;
61043
61044   {
61045     try {
61046       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61047     } catch (std::out_of_range& e) {
61048       {
61049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (std::exception& e) {
61052       {
61053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (Dali::DaliException e) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61058       };
61059     } catch (...) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61062       };
61063     }
61064   }
61065
61066   jresult = (int)result;
61067   return jresult;
61068 }
61069
61070
61071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61072   int jresult ;
61073   int result;
61074
61075   {
61076     try {
61077       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61078     } catch (std::out_of_range& e) {
61079       {
61080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (std::exception& e) {
61083       {
61084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (Dali::DaliException e) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096
61097   jresult = (int)result;
61098   return jresult;
61099 }
61100
61101
61102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61103   int jresult ;
61104   int result;
61105
61106   {
61107     try {
61108       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61109     } catch (std::out_of_range& e) {
61110       {
61111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (std::exception& e) {
61114       {
61115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (Dali::DaliException e) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127
61128   jresult = (int)result;
61129   return jresult;
61130 }
61131
61132
61133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61134   int jresult ;
61135   int result;
61136
61137   {
61138     try {
61139       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61140     } catch (std::out_of_range& e) {
61141       {
61142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61143       };
61144     } catch (std::exception& e) {
61145       {
61146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (Dali::DaliException e) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61151       };
61152     } catch (...) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61155       };
61156     }
61157   }
61158
61159   jresult = (int)result;
61160   return jresult;
61161 }
61162
61163
61164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61165   void * jresult ;
61166   Dali::Toolkit::Builder *result = 0 ;
61167
61168   {
61169     try {
61170       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61171     } catch (std::out_of_range& e) {
61172       {
61173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61174       };
61175     } catch (std::exception& e) {
61176       {
61177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61178       };
61179     } catch (Dali::DaliException e) {
61180       {
61181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61186       };
61187     }
61188   }
61189
61190   jresult = (void *)result;
61191   return jresult;
61192 }
61193
61194
61195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61196   void * jresult ;
61197   Dali::Toolkit::Builder result;
61198
61199   {
61200     try {
61201       result = Dali::Toolkit::Builder::New();
61202     } catch (std::out_of_range& e) {
61203       {
61204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61205       };
61206     } catch (std::exception& e) {
61207       {
61208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61209       };
61210     } catch (Dali::DaliException e) {
61211       {
61212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61213       };
61214     } catch (...) {
61215       {
61216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61217       };
61218     }
61219   }
61220
61221   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61222   return jresult;
61223 }
61224
61225
61226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61227   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61228
61229   arg1 = (Dali::Toolkit::Builder *)jarg1;
61230   {
61231     try {
61232       delete arg1;
61233     } catch (std::out_of_range& e) {
61234       {
61235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61236       };
61237     } catch (std::exception& e) {
61238       {
61239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61240       };
61241     } catch (Dali::DaliException e) {
61242       {
61243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61248       };
61249     }
61250   }
61251
61252 }
61253
61254
61255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61257   std::string *arg2 = 0 ;
61258   Dali::Toolkit::Builder::UIFormat arg3 ;
61259
61260   arg1 = (Dali::Toolkit::Builder *)jarg1;
61261   if (!jarg2) {
61262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61263     return ;
61264   }
61265   std::string arg2_str(jarg2);
61266   arg2 = &arg2_str;
61267   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61268   {
61269     try {
61270       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (Dali::DaliException e) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61282       };
61283     } catch (...) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61286       };
61287     }
61288   }
61289
61290
61291   //argout typemap for const std::string&
61292
61293 }
61294
61295
61296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61297   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61298   std::string *arg2 = 0 ;
61299
61300   arg1 = (Dali::Toolkit::Builder *)jarg1;
61301   if (!jarg2) {
61302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61303     return ;
61304   }
61305   std::string arg2_str(jarg2);
61306   arg2 = &arg2_str;
61307   {
61308     try {
61309       (arg1)->LoadFromString((std::string const &)*arg2);
61310     } catch (std::out_of_range& e) {
61311       {
61312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61313       };
61314     } catch (std::exception& e) {
61315       {
61316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61317       };
61318     } catch (Dali::DaliException e) {
61319       {
61320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61325       };
61326     }
61327   }
61328
61329
61330   //argout typemap for const std::string&
61331
61332 }
61333
61334
61335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61336   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61337   Dali::Property::Map *arg2 = 0 ;
61338
61339   arg1 = (Dali::Toolkit::Builder *)jarg1;
61340   arg2 = (Dali::Property::Map *)jarg2;
61341   if (!arg2) {
61342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61343     return ;
61344   }
61345   {
61346     try {
61347       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61348     } catch (std::out_of_range& e) {
61349       {
61350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61351       };
61352     } catch (std::exception& e) {
61353       {
61354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61355       };
61356     } catch (Dali::DaliException e) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61363       };
61364     }
61365   }
61366
61367 }
61368
61369
61370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61371   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61372   std::string *arg2 = 0 ;
61373   Dali::Property::Value *arg3 = 0 ;
61374
61375   arg1 = (Dali::Toolkit::Builder *)jarg1;
61376   if (!jarg2) {
61377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61378     return ;
61379   }
61380   std::string arg2_str(jarg2);
61381   arg2 = &arg2_str;
61382   arg3 = (Dali::Property::Value *)jarg3;
61383   if (!arg3) {
61384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61385     return ;
61386   }
61387   {
61388     try {
61389       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61390     } catch (std::out_of_range& e) {
61391       {
61392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61393       };
61394     } catch (std::exception& e) {
61395       {
61396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61397       };
61398     } catch (Dali::DaliException e) {
61399       {
61400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61401       };
61402     } catch (...) {
61403       {
61404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61405       };
61406     }
61407   }
61408
61409
61410   //argout typemap for const std::string&
61411
61412 }
61413
61414
61415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61416   void * jresult ;
61417   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61418   Dali::Property::Map *result = 0 ;
61419
61420   arg1 = (Dali::Toolkit::Builder *)jarg1;
61421   {
61422     try {
61423       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61424     } catch (std::out_of_range& e) {
61425       {
61426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (std::exception& e) {
61429       {
61430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (Dali::DaliException e) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61435       };
61436     } catch (...) {
61437       {
61438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61439       };
61440     }
61441   }
61442
61443   jresult = (void *)result;
61444   return jresult;
61445 }
61446
61447
61448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61449   void * jresult ;
61450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61451   std::string *arg2 = 0 ;
61452   Dali::Property::Value *result = 0 ;
61453
61454   arg1 = (Dali::Toolkit::Builder *)jarg1;
61455   if (!jarg2) {
61456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61457     return 0;
61458   }
61459   std::string arg2_str(jarg2);
61460   arg2 = &arg2_str;
61461   {
61462     try {
61463       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61464     } catch (std::out_of_range& e) {
61465       {
61466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (std::exception& e) {
61469       {
61470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61471       };
61472     } catch (Dali::DaliException e) {
61473       {
61474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61475       };
61476     } catch (...) {
61477       {
61478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61479       };
61480     }
61481   }
61482
61483   jresult = (void *)result;
61484
61485   //argout typemap for const std::string&
61486
61487   return jresult;
61488 }
61489
61490
61491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61492   void * jresult ;
61493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61494   std::string *arg2 = 0 ;
61495   Dali::Animation result;
61496
61497   arg1 = (Dali::Toolkit::Builder *)jarg1;
61498   if (!jarg2) {
61499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61500     return 0;
61501   }
61502   std::string arg2_str(jarg2);
61503   arg2 = &arg2_str;
61504   {
61505     try {
61506       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61507     } catch (std::out_of_range& e) {
61508       {
61509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61510       };
61511     } catch (std::exception& e) {
61512       {
61513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (Dali::DaliException e) {
61516       {
61517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525
61526   jresult = new Dali::Animation((const Dali::Animation &)result);
61527
61528   //argout typemap for const std::string&
61529
61530   return jresult;
61531 }
61532
61533
61534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61535   void * jresult ;
61536   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61537   std::string *arg2 = 0 ;
61538   Dali::Property::Map *arg3 = 0 ;
61539   Dali::Animation result;
61540
61541   arg1 = (Dali::Toolkit::Builder *)jarg1;
61542   if (!jarg2) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61544     return 0;
61545   }
61546   std::string arg2_str(jarg2);
61547   arg2 = &arg2_str;
61548   arg3 = (Dali::Property::Map *)jarg3;
61549   if (!arg3) {
61550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61551     return 0;
61552   }
61553   {
61554     try {
61555       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61556     } catch (std::out_of_range& e) {
61557       {
61558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61559       };
61560     } catch (std::exception& e) {
61561       {
61562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61563       };
61564     } catch (Dali::DaliException e) {
61565       {
61566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61571       };
61572     }
61573   }
61574
61575   jresult = new Dali::Animation((const Dali::Animation &)result);
61576
61577   //argout typemap for const std::string&
61578
61579   return jresult;
61580 }
61581
61582
61583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61584   void * jresult ;
61585   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61586   std::string *arg2 = 0 ;
61587   Dali::Actor arg3 ;
61588   Dali::Actor *argp3 ;
61589   Dali::Animation result;
61590
61591   arg1 = (Dali::Toolkit::Builder *)jarg1;
61592   if (!jarg2) {
61593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61594     return 0;
61595   }
61596   std::string arg2_str(jarg2);
61597   arg2 = &arg2_str;
61598   argp3 = (Dali::Actor *)jarg3;
61599   if (!argp3) {
61600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61601     return 0;
61602   }
61603   arg3 = *argp3;
61604   {
61605     try {
61606       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61607     } catch (std::out_of_range& e) {
61608       {
61609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61610       };
61611     } catch (std::exception& e) {
61612       {
61613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61614       };
61615     } catch (Dali::DaliException e) {
61616       {
61617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61618       };
61619     } catch (...) {
61620       {
61621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61622       };
61623     }
61624   }
61625
61626   jresult = new Dali::Animation((const Dali::Animation &)result);
61627
61628   //argout typemap for const std::string&
61629
61630   return jresult;
61631 }
61632
61633
61634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61635   void * jresult ;
61636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61637   std::string *arg2 = 0 ;
61638   Dali::Property::Map *arg3 = 0 ;
61639   Dali::Actor arg4 ;
61640   Dali::Actor *argp4 ;
61641   Dali::Animation result;
61642
61643   arg1 = (Dali::Toolkit::Builder *)jarg1;
61644   if (!jarg2) {
61645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61646     return 0;
61647   }
61648   std::string arg2_str(jarg2);
61649   arg2 = &arg2_str;
61650   arg3 = (Dali::Property::Map *)jarg3;
61651   if (!arg3) {
61652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61653     return 0;
61654   }
61655   argp4 = (Dali::Actor *)jarg4;
61656   if (!argp4) {
61657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61658     return 0;
61659   }
61660   arg4 = *argp4;
61661   {
61662     try {
61663       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61664     } catch (std::out_of_range& e) {
61665       {
61666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (std::exception& e) {
61669       {
61670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (Dali::DaliException e) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61675       };
61676     } catch (...) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61679       };
61680     }
61681   }
61682
61683   jresult = new Dali::Animation((const Dali::Animation &)result);
61684
61685   //argout typemap for const std::string&
61686
61687   return jresult;
61688 }
61689
61690
61691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61692   void * jresult ;
61693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61694   std::string *arg2 = 0 ;
61695   Dali::BaseHandle result;
61696
61697   arg1 = (Dali::Toolkit::Builder *)jarg1;
61698   if (!jarg2) {
61699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61700     return 0;
61701   }
61702   std::string arg2_str(jarg2);
61703   arg2 = &arg2_str;
61704   {
61705     try {
61706       result = (arg1)->Create((std::string const &)*arg2);
61707     } catch (std::out_of_range& e) {
61708       {
61709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61710       };
61711     } catch (std::exception& e) {
61712       {
61713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (Dali::DaliException e) {
61716       {
61717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61718       };
61719     } catch (...) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61722       };
61723     }
61724   }
61725
61726   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61727
61728   //argout typemap for const std::string&
61729
61730   return jresult;
61731 }
61732
61733
61734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61735   void * jresult ;
61736   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61737   std::string *arg2 = 0 ;
61738   Dali::Property::Map *arg3 = 0 ;
61739   Dali::BaseHandle result;
61740
61741   arg1 = (Dali::Toolkit::Builder *)jarg1;
61742   if (!jarg2) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61744     return 0;
61745   }
61746   std::string arg2_str(jarg2);
61747   arg2 = &arg2_str;
61748   arg3 = (Dali::Property::Map *)jarg3;
61749   if (!arg3) {
61750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61751     return 0;
61752   }
61753   {
61754     try {
61755       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61756     } catch (std::out_of_range& e) {
61757       {
61758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61759       };
61760     } catch (std::exception& e) {
61761       {
61762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61763       };
61764     } catch (Dali::DaliException e) {
61765       {
61766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61771       };
61772     }
61773   }
61774
61775   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61776
61777   //argout typemap for const std::string&
61778
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61784   void * jresult ;
61785   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61786   std::string *arg2 = 0 ;
61787   Dali::BaseHandle result;
61788
61789   arg1 = (Dali::Toolkit::Builder *)jarg1;
61790   if (!jarg2) {
61791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61792     return 0;
61793   }
61794   std::string arg2_str(jarg2);
61795   arg2 = &arg2_str;
61796   {
61797     try {
61798       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61799     } catch (std::out_of_range& e) {
61800       {
61801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (std::exception& e) {
61804       {
61805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61806       };
61807     } catch (Dali::DaliException e) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61810       };
61811     } catch (...) {
61812       {
61813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61814       };
61815     }
61816   }
61817
61818   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61819
61820   //argout typemap for const std::string&
61821
61822   return jresult;
61823 }
61824
61825
61826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61827   unsigned int jresult ;
61828   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61829   std::string *arg2 = 0 ;
61830   Dali::Handle *arg3 = 0 ;
61831   bool result;
61832
61833   arg1 = (Dali::Toolkit::Builder *)jarg1;
61834   if (!jarg2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61836     return 0;
61837   }
61838   std::string arg2_str(jarg2);
61839   arg2 = &arg2_str;
61840   arg3 = (Dali::Handle *)jarg3;
61841   if (!arg3) {
61842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61843     return 0;
61844   }
61845   {
61846     try {
61847       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61863       };
61864     }
61865   }
61866
61867   jresult = result;
61868
61869   //argout typemap for const std::string&
61870
61871   return jresult;
61872 }
61873
61874
61875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61876   unsigned int jresult ;
61877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61878   Dali::Handle *arg2 = 0 ;
61879   std::string *arg3 = 0 ;
61880   bool result;
61881
61882   arg1 = (Dali::Toolkit::Builder *)jarg1;
61883   arg2 = (Dali::Handle *)jarg2;
61884   if (!arg2) {
61885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61886     return 0;
61887   }
61888   if (!jarg3) {
61889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61890     return 0;
61891   }
61892   std::string arg3_str(jarg3);
61893   arg3 = &arg3_str;
61894   {
61895     try {
61896       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61897     } catch (std::out_of_range& e) {
61898       {
61899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61900       };
61901     } catch (std::exception& e) {
61902       {
61903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61904       };
61905     } catch (Dali::DaliException e) {
61906       {
61907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61908       };
61909     } catch (...) {
61910       {
61911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61912       };
61913     }
61914   }
61915
61916   jresult = result;
61917
61918   //argout typemap for const std::string&
61919
61920   return jresult;
61921 }
61922
61923
61924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61925   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61926   Dali::Actor arg2 ;
61927   Dali::Actor *argp2 ;
61928
61929   arg1 = (Dali::Toolkit::Builder *)jarg1;
61930   argp2 = (Dali::Actor *)jarg2;
61931   if (!argp2) {
61932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61933     return ;
61934   }
61935   arg2 = *argp2;
61936   {
61937     try {
61938       (arg1)->AddActors(arg2);
61939     } catch (std::out_of_range& e) {
61940       {
61941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61942       };
61943     } catch (std::exception& e) {
61944       {
61945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61946       };
61947     } catch (Dali::DaliException e) {
61948       {
61949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61950       };
61951     } catch (...) {
61952       {
61953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61954       };
61955     }
61956   }
61957
61958 }
61959
61960
61961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Actor arg3 ;
61965   Dali::Actor *argp3 ;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return ;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   argp3 = (Dali::Actor *)jarg3;
61975   if (!argp3) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61977     return ;
61978   }
61979   arg3 = *argp3;
61980   {
61981     try {
61982       (arg1)->AddActors((std::string const &)*arg2,arg3);
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61990       };
61991     } catch (Dali::DaliException e) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61994       };
61995     } catch (...) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61998       };
61999     }
62000   }
62001
62002
62003   //argout typemap for const std::string&
62004
62005 }
62006
62007
62008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62009   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62010   std::string *arg2 = 0 ;
62011
62012   arg1 = (Dali::Toolkit::Builder *)jarg1;
62013   if (!jarg2) {
62014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62015     return ;
62016   }
62017   std::string arg2_str(jarg2);
62018   arg2 = &arg2_str;
62019   {
62020     try {
62021       (arg1)->CreateRenderTask((std::string const &)*arg2);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62029       };
62030     } catch (Dali::DaliException e) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62033       };
62034     } catch (...) {
62035       {
62036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62037       };
62038     }
62039   }
62040
62041
62042   //argout typemap for const std::string&
62043
62044 }
62045
62046
62047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62048   void * jresult ;
62049   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62050   std::string *arg2 = 0 ;
62051   Dali::Path result;
62052
62053   arg1 = (Dali::Toolkit::Builder *)jarg1;
62054   if (!jarg2) {
62055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62056     return 0;
62057   }
62058   std::string arg2_str(jarg2);
62059   arg2 = &arg2_str;
62060   {
62061     try {
62062       result = (arg1)->GetPath((std::string const &)*arg2);
62063     } catch (std::out_of_range& e) {
62064       {
62065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62066       };
62067     } catch (std::exception& e) {
62068       {
62069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62070       };
62071     } catch (Dali::DaliException e) {
62072       {
62073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62074       };
62075     } catch (...) {
62076       {
62077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62078       };
62079     }
62080   }
62081
62082   jresult = new Dali::Path((const Dali::Path &)result);
62083
62084   //argout typemap for const std::string&
62085
62086   return jresult;
62087 }
62088
62089
62090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62091   void * jresult ;
62092   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62093   std::string *arg2 = 0 ;
62094   Dali::PathConstrainer result;
62095
62096   arg1 = (Dali::Toolkit::Builder *)jarg1;
62097   if (!jarg2) {
62098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62099     return 0;
62100   }
62101   std::string arg2_str(jarg2);
62102   arg2 = &arg2_str;
62103   {
62104     try {
62105       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62121       };
62122     }
62123   }
62124
62125   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62126
62127   //argout typemap for const std::string&
62128
62129   return jresult;
62130 }
62131
62132
62133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62134   void * jresult ;
62135   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62136   std::string *arg2 = 0 ;
62137   Dali::LinearConstrainer result;
62138
62139   arg1 = (Dali::Toolkit::Builder *)jarg1;
62140   if (!jarg2) {
62141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62142     return 0;
62143   }
62144   std::string arg2_str(jarg2);
62145   arg2 = &arg2_str;
62146   {
62147     try {
62148       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62149     } catch (std::out_of_range& e) {
62150       {
62151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62152       };
62153     } catch (std::exception& e) {
62154       {
62155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62156       };
62157     } catch (Dali::DaliException e) {
62158       {
62159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62160       };
62161     } catch (...) {
62162       {
62163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62164       };
62165     }
62166   }
62167
62168   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62169
62170   //argout typemap for const std::string&
62171
62172   return jresult;
62173 }
62174
62175
62176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62177   void * jresult ;
62178   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62179   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62180
62181   arg1 = (Dali::Toolkit::Builder *)jarg1;
62182   {
62183     try {
62184       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62185     } catch (std::out_of_range& e) {
62186       {
62187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62188       };
62189     } catch (std::exception& e) {
62190       {
62191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62192       };
62193     } catch (Dali::DaliException e) {
62194       {
62195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62196       };
62197     } catch (...) {
62198       {
62199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62200       };
62201     }
62202   }
62203
62204   jresult = (void *)result;
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62210   void * jresult ;
62211   Dali::Toolkit::TransitionData *result = 0 ;
62212
62213   {
62214     try {
62215       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62231       };
62232     }
62233   }
62234
62235   jresult = (void *)result;
62236   return jresult;
62237 }
62238
62239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62240   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62241
62242   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62243   {
62244     try {
62245       delete arg1;
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62253       };
62254     } catch (Dali::DaliException e) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62257       };
62258     } catch (...) {
62259       {
62260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62261       };
62262     }
62263   }
62264
62265 }
62266
62267
62268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62269   void * jresult ;
62270   Dali::Property::Map *arg1 = 0 ;
62271   Dali::Toolkit::TransitionData result;
62272
62273   arg1 = (Dali::Property::Map *)jarg1;
62274   if (!arg1) {
62275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62276     return 0;
62277   }
62278   {
62279     try {
62280       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62281     } catch (std::out_of_range& e) {
62282       {
62283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62284       };
62285     } catch (std::exception& e) {
62286       {
62287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62288       };
62289     } catch (Dali::DaliException e) {
62290       {
62291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62292       };
62293     } catch (...) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62296       };
62297     }
62298   }
62299
62300   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62301   return jresult;
62302 }
62303
62304
62305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62306   void * jresult ;
62307   Dali::Property::Array *arg1 = 0 ;
62308   Dali::Toolkit::TransitionData result;
62309
62310   arg1 = (Dali::Property::Array *)jarg1;
62311   if (!arg1) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62313     return 0;
62314   }
62315   {
62316     try {
62317       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336
62337   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62338   return jresult;
62339 }
62340
62341
62342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62343   void * jresult ;
62344   Dali::BaseHandle arg1 ;
62345   Dali::BaseHandle *argp1 ;
62346   Dali::Toolkit::TransitionData result;
62347
62348   argp1 = (Dali::BaseHandle *)jarg1;
62349   if (!argp1) {
62350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62351     return 0;
62352   }
62353   arg1 = *argp1;
62354   {
62355     try {
62356       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62357     } catch (std::out_of_range& e) {
62358       {
62359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62360       };
62361     } catch (std::exception& e) {
62362       {
62363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (Dali::DaliException e) {
62366       {
62367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62368       };
62369     } catch (...) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62372       };
62373     }
62374   }
62375
62376   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62382   void * jresult ;
62383   Dali::Toolkit::TransitionData *arg1 = 0 ;
62384   Dali::Toolkit::TransitionData *result = 0 ;
62385
62386   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62387   if (!arg1) {
62388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62389     return 0;
62390   }
62391   {
62392     try {
62393       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (Dali::DaliException e) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62409       };
62410     }
62411   }
62412
62413   jresult = (void *)result;
62414   return jresult;
62415 }
62416
62417
62418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62419   void * jresult ;
62420   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62421   Dali::Toolkit::TransitionData *arg2 = 0 ;
62422   Dali::Toolkit::TransitionData *result = 0 ;
62423
62424   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62425   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62426   if (!arg2) {
62427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62428     return 0;
62429   }
62430   {
62431     try {
62432       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62433     } catch (std::out_of_range& e) {
62434       {
62435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (std::exception& e) {
62438       {
62439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62440       };
62441     } catch (Dali::DaliException e) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62448       };
62449     }
62450   }
62451
62452   jresult = (void *)result;
62453   return jresult;
62454 }
62455
62456
62457 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62458   unsigned long jresult ;
62459   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62460   size_t result;
62461
62462   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62463   {
62464     try {
62465       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62466     } catch (std::out_of_range& e) {
62467       {
62468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (std::exception& e) {
62471       {
62472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62473       };
62474     } catch (Dali::DaliException e) {
62475       {
62476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62477       };
62478     } catch (...) {
62479       {
62480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62481       };
62482     }
62483   }
62484
62485   jresult = (unsigned long)result;
62486   return jresult;
62487 }
62488
62489
62490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62491   void * jresult ;
62492   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62493   size_t arg2 ;
62494   Dali::Property::Map result;
62495
62496   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62497   arg2 = (size_t)jarg2;
62498   {
62499     try {
62500       result = (arg1)->GetAnimatorAt(arg2);
62501     } catch (std::out_of_range& e) {
62502       {
62503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62504       };
62505     } catch (std::exception& e) {
62506       {
62507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62508       };
62509     } catch (Dali::DaliException e) {
62510       {
62511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62512       };
62513     } catch (...) {
62514       {
62515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62516       };
62517     }
62518   }
62519
62520   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62521   return jresult;
62522 }
62523
62524
62525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62526   int jresult ;
62527   int result;
62528
62529   {
62530     try {
62531       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = (int)result;
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62557   int jresult ;
62558   int result;
62559
62560   {
62561     try {
62562       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62563     } catch (std::out_of_range& e) {
62564       {
62565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62566       };
62567     } catch (std::exception& e) {
62568       {
62569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62570       };
62571     } catch (Dali::DaliException e) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62574       };
62575     } catch (...) {
62576       {
62577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62578       };
62579     }
62580   }
62581
62582   jresult = (int)result;
62583   return jresult;
62584 }
62585
62586
62587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62588   int jresult ;
62589   int result;
62590
62591   {
62592     try {
62593       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62594     } catch (std::out_of_range& e) {
62595       {
62596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62597       };
62598     } catch (std::exception& e) {
62599       {
62600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62601       };
62602     } catch (Dali::DaliException e) {
62603       {
62604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62605       };
62606     } catch (...) {
62607       {
62608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62609       };
62610     }
62611   }
62612
62613   jresult = (int)result;
62614   return jresult;
62615 }
62616
62617
62618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62619   int jresult ;
62620   int result;
62621
62622   {
62623     try {
62624       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62625     } catch (std::out_of_range& e) {
62626       {
62627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62628       };
62629     } catch (std::exception& e) {
62630       {
62631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62632       };
62633     } catch (Dali::DaliException e) {
62634       {
62635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62636       };
62637     } catch (...) {
62638       {
62639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62640       };
62641     }
62642   }
62643
62644   jresult = (int)result;
62645   return jresult;
62646 }
62647
62648
62649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62650   int jresult ;
62651   int result;
62652
62653   {
62654     try {
62655       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62656     } catch (std::out_of_range& e) {
62657       {
62658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (std::exception& e) {
62661       {
62662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (Dali::DaliException e) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62667       };
62668     } catch (...) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62671       };
62672     }
62673   }
62674
62675   jresult = (int)result;
62676   return jresult;
62677 }
62678
62679
62680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62681   int jresult ;
62682   int result;
62683
62684   {
62685     try {
62686       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62687     } catch (std::out_of_range& e) {
62688       {
62689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62690       };
62691     } catch (std::exception& e) {
62692       {
62693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62694       };
62695     } catch (Dali::DaliException e) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62698       };
62699     } catch (...) {
62700       {
62701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62702       };
62703     }
62704   }
62705
62706   jresult = (int)result;
62707   return jresult;
62708 }
62709
62710
62711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62712   int jresult ;
62713   int result;
62714
62715   {
62716     try {
62717       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62733       };
62734     }
62735   }
62736
62737   jresult = (int)result;
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62743   int jresult ;
62744   int result;
62745
62746   {
62747     try {
62748       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62749     } catch (std::out_of_range& e) {
62750       {
62751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62752       };
62753     } catch (std::exception& e) {
62754       {
62755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62756       };
62757     } catch (Dali::DaliException e) {
62758       {
62759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62760       };
62761     } catch (...) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62764       };
62765     }
62766   }
62767
62768   jresult = (int)result;
62769   return jresult;
62770 }
62771
62772
62773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62774   int jresult ;
62775   int result;
62776
62777   {
62778     try {
62779       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62780     } catch (std::out_of_range& e) {
62781       {
62782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62783       };
62784     } catch (std::exception& e) {
62785       {
62786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (Dali::DaliException e) {
62789       {
62790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62795       };
62796     }
62797   }
62798
62799   jresult = (int)result;
62800   return jresult;
62801 }
62802
62803
62804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62805   int jresult ;
62806   int result;
62807
62808   {
62809     try {
62810       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62811     } catch (std::out_of_range& e) {
62812       {
62813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62814       };
62815     } catch (std::exception& e) {
62816       {
62817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62818       };
62819     } catch (Dali::DaliException e) {
62820       {
62821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62822       };
62823     } catch (...) {
62824       {
62825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62826       };
62827     }
62828   }
62829
62830   jresult = (int)result;
62831   return jresult;
62832 }
62833
62834
62835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62836   int jresult ;
62837   int result;
62838
62839   {
62840     try {
62841       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62849       };
62850     } catch (Dali::DaliException e) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62857       };
62858     }
62859   }
62860
62861   jresult = (int)result;
62862   return jresult;
62863 }
62864
62865
62866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62867   int jresult ;
62868   int result;
62869
62870   {
62871     try {
62872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62873     } catch (std::out_of_range& e) {
62874       {
62875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62876       };
62877     } catch (std::exception& e) {
62878       {
62879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62880       };
62881     } catch (Dali::DaliException e) {
62882       {
62883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62884       };
62885     } catch (...) {
62886       {
62887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62888       };
62889     }
62890   }
62891
62892   jresult = (int)result;
62893   return jresult;
62894 }
62895
62896
62897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62898   int jresult ;
62899   int result;
62900
62901   {
62902     try {
62903       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62904     } catch (std::out_of_range& e) {
62905       {
62906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62907       };
62908     } catch (std::exception& e) {
62909       {
62910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (Dali::DaliException e) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62915       };
62916     } catch (...) {
62917       {
62918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62919       };
62920     }
62921   }
62922
62923   jresult = (int)result;
62924   return jresult;
62925 }
62926
62927
62928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62929   int jresult ;
62930   int result;
62931
62932   {
62933     try {
62934       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62950       };
62951     }
62952   }
62953
62954   jresult = (int)result;
62955   return jresult;
62956 }
62957
62958
62959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62960   void * jresult ;
62961   Dali::Toolkit::Control result;
62962
62963   {
62964     try {
62965       result = Dali::Toolkit::Internal::Control::New();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (Dali::DaliException e) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62981       };
62982     }
62983   }
62984
62985   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62986   return jresult;
62987 }
62988
62989
62990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62992   std::string *arg2 = 0 ;
62993
62994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62995   if (!jarg2) {
62996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62997     return ;
62998   }
62999   std::string arg2_str(jarg2);
63000   arg2 = &arg2_str;
63001   {
63002     try {
63003       (arg1)->SetStyleName((std::string const &)*arg2);
63004     } catch (std::out_of_range& e) {
63005       {
63006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63007       };
63008     } catch (std::exception& e) {
63009       {
63010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63011       };
63012     } catch (Dali::DaliException e) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63015       };
63016     } catch (...) {
63017       {
63018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63019       };
63020     }
63021   }
63022
63023
63024   //argout typemap for const std::string&
63025
63026 }
63027
63028
63029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63030   char * jresult ;
63031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63032   std::string *result = 0 ;
63033
63034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63035   {
63036     try {
63037       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63038     } catch (std::out_of_range& e) {
63039       {
63040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63041       };
63042     } catch (std::exception& e) {
63043       {
63044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63045       };
63046     } catch (Dali::DaliException e) {
63047       {
63048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63049       };
63050     } catch (...) {
63051       {
63052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63053       };
63054     }
63055   }
63056
63057   jresult = SWIG_csharp_string_callback(result->c_str());
63058   return jresult;
63059 }
63060
63061
63062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63063   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63064   Dali::Vector4 *arg2 = 0 ;
63065
63066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63067   arg2 = (Dali::Vector4 *)jarg2;
63068   if (!arg2) {
63069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63070     return ;
63071   }
63072   {
63073     try {
63074       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63075     } catch (std::out_of_range& e) {
63076       {
63077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63078       };
63079     } catch (std::exception& e) {
63080       {
63081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63082       };
63083     } catch (Dali::DaliException e) {
63084       {
63085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63086       };
63087     } catch (...) {
63088       {
63089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63090       };
63091     }
63092   }
63093
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63098   void * jresult ;
63099   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63100   Dali::Vector4 result;
63101
63102   arg1 = (Dali::Handle *)jarg1;
63103   {
63104     try {
63105       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63106       if (resultMap)
63107       {
63108         if(resultMap->Find( Toolkit::Visual::Property::TYPE )->Get<int>() == Visual::COLOR )
63109         {
63110           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
63111           if (value)
63112           {
63113             result = value->Get<Vector4>();
63114           }
63115         }
63116       }
63117     } catch (std::out_of_range& e) {
63118       {
63119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63120       };
63121     } catch (std::exception& e) {
63122       {
63123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63124       };
63125     } catch (Dali::DaliException e) {
63126       {
63127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63128       };
63129     } catch (...) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63132       };
63133     }
63134   }
63135
63136   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63137   return jresult;
63138 }
63139
63140
63141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63143   Dali::Property::Map *arg2 = 0 ;
63144
63145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63146   arg2 = (Dali::Property::Map *)jarg2;
63147   if (!arg2) {
63148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63149     return ;
63150   }
63151   {
63152     try {
63153       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63154     } catch (std::out_of_range& e) {
63155       {
63156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63157       };
63158     } catch (std::exception& e) {
63159       {
63160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63161       };
63162     } catch (Dali::DaliException e) {
63163       {
63164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63165       };
63166     } catch (...) {
63167       {
63168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63169       };
63170     }
63171   }
63172
63173 }
63174
63175
63176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63178
63179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63180   {
63181     try {
63182       (arg1)->ClearBackground();
63183     } catch (std::out_of_range& e) {
63184       {
63185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63186       };
63187     } catch (std::exception& e) {
63188       {
63189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63190       };
63191     } catch (Dali::DaliException e) {
63192       {
63193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63194       };
63195     } catch (...) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63198       };
63199     }
63200   }
63201
63202 }
63203
63204
63205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63207   Dali::Gesture::Type arg2 ;
63208
63209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63210   arg2 = (Dali::Gesture::Type)jarg2;
63211   {
63212     try {
63213       (arg1)->EnableGestureDetection(arg2);
63214     } catch (std::out_of_range& e) {
63215       {
63216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (std::exception& e) {
63219       {
63220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63221       };
63222     } catch (Dali::DaliException e) {
63223       {
63224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63225       };
63226     } catch (...) {
63227       {
63228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63229       };
63230     }
63231   }
63232
63233 }
63234
63235
63236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63238   Dali::Gesture::Type arg2 ;
63239
63240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63241   arg2 = (Dali::Gesture::Type)jarg2;
63242   {
63243     try {
63244       (arg1)->DisableGestureDetection(arg2);
63245     } catch (std::out_of_range& e) {
63246       {
63247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63248       };
63249     } catch (std::exception& e) {
63250       {
63251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63252       };
63253     } catch (Dali::DaliException e) {
63254       {
63255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63256       };
63257     } catch (...) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63260       };
63261     }
63262   }
63263
63264 }
63265
63266
63267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63268   void * jresult ;
63269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63270   Dali::PinchGestureDetector result;
63271
63272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63273   {
63274     try {
63275       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63276     } catch (std::out_of_range& e) {
63277       {
63278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63279       };
63280     } catch (std::exception& e) {
63281       {
63282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63283       };
63284     } catch (Dali::DaliException e) {
63285       {
63286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63287       };
63288     } catch (...) {
63289       {
63290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63291       };
63292     }
63293   }
63294
63295   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63296   return jresult;
63297 }
63298
63299
63300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63301   void * jresult ;
63302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63303   Dali::PanGestureDetector result;
63304
63305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63306   {
63307     try {
63308       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63309     } catch (std::out_of_range& e) {
63310       {
63311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63312       };
63313     } catch (std::exception& e) {
63314       {
63315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63316       };
63317     } catch (Dali::DaliException e) {
63318       {
63319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63320       };
63321     } catch (...) {
63322       {
63323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63324       };
63325     }
63326   }
63327
63328   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63329   return jresult;
63330 }
63331
63332
63333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63334   void * jresult ;
63335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63336   Dali::TapGestureDetector result;
63337
63338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63339   {
63340     try {
63341       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63367   void * jresult ;
63368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63369   Dali::LongPressGestureDetector result;
63370
63371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63372   {
63373     try {
63374       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63375     } catch (std::out_of_range& e) {
63376       {
63377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (std::exception& e) {
63380       {
63381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63382       };
63383     } catch (Dali::DaliException e) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63386       };
63387     } catch (...) {
63388       {
63389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63390       };
63391     }
63392   }
63393
63394   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63395   return jresult;
63396 }
63397
63398
63399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63401   bool arg2 ;
63402
63403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63404   arg2 = jarg2 ? true : false;
63405   {
63406     try {
63407       (arg1)->SetKeyboardNavigationSupport(arg2);
63408     } catch (std::out_of_range& e) {
63409       {
63410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63411       };
63412     } catch (std::exception& e) {
63413       {
63414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63415       };
63416     } catch (Dali::DaliException e) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63419       };
63420     } catch (...) {
63421       {
63422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63423       };
63424     }
63425   }
63426
63427 }
63428
63429
63430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63431   unsigned int jresult ;
63432   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63433   bool result;
63434
63435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63436   {
63437     try {
63438       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63439     } catch (std::out_of_range& e) {
63440       {
63441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (std::exception& e) {
63444       {
63445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63446       };
63447     } catch (Dali::DaliException e) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63450       };
63451     } catch (...) {
63452       {
63453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63454       };
63455     }
63456   }
63457
63458   jresult = result;
63459   return jresult;
63460 }
63461
63462
63463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63465
63466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63467   {
63468     try {
63469       (arg1)->SetKeyInputFocus();
63470     } catch (std::out_of_range& e) {
63471       {
63472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (std::exception& e) {
63475       {
63476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (Dali::DaliException e) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63481       };
63482     } catch (...) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63485       };
63486     }
63487   }
63488
63489 }
63490
63491
63492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63493   unsigned int jresult ;
63494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63495   bool result;
63496
63497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63498   {
63499     try {
63500       result = (bool)(arg1)->HasKeyInputFocus();
63501     } catch (std::out_of_range& e) {
63502       {
63503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63504       };
63505     } catch (std::exception& e) {
63506       {
63507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63508       };
63509     } catch (Dali::DaliException e) {
63510       {
63511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63512       };
63513     } catch (...) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63516       };
63517     }
63518   }
63519
63520   jresult = result;
63521   return jresult;
63522 }
63523
63524
63525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63527
63528   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63529   {
63530     try {
63531       (arg1)->ClearKeyInputFocus();
63532     } catch (std::out_of_range& e) {
63533       {
63534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63535       };
63536     } catch (std::exception& e) {
63537       {
63538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63539       };
63540     } catch (Dali::DaliException e) {
63541       {
63542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63543       };
63544     } catch (...) {
63545       {
63546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63547       };
63548     }
63549   }
63550
63551 }
63552
63553
63554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63556   bool arg2 ;
63557
63558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63559   arg2 = jarg2 ? true : false;
63560   {
63561     try {
63562       (arg1)->SetAsKeyboardFocusGroup(arg2);
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63570       };
63571     } catch (Dali::DaliException e) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63578       };
63579     }
63580   }
63581
63582 }
63583
63584
63585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63586   unsigned int jresult ;
63587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63588   bool result;
63589
63590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63591   {
63592     try {
63593       result = (bool)(arg1)->IsKeyboardFocusGroup();
63594     } catch (std::out_of_range& e) {
63595       {
63596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63597       };
63598     } catch (std::exception& e) {
63599       {
63600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63601       };
63602     } catch (Dali::DaliException e) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63605       };
63606     } catch (...) {
63607       {
63608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63609       };
63610     }
63611   }
63612
63613   jresult = result;
63614   return jresult;
63615 }
63616
63617
63618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63619   void * jresult ;
63620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63621   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63622
63623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63624   {
63625     try {
63626       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63627     } catch (std::out_of_range& e) {
63628       {
63629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63630       };
63631     } catch (std::exception& e) {
63632       {
63633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63634       };
63635     } catch (Dali::DaliException e) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63638       };
63639     } catch (...) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63642       };
63643     }
63644   }
63645
63646   jresult = (void *)result;
63647   return jresult;
63648 }
63649
63650
63651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63652   void * jresult ;
63653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63654   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63655
63656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63657   {
63658     try {
63659       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63660     } catch (std::out_of_range& e) {
63661       {
63662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (std::exception& e) {
63665       {
63666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (Dali::DaliException e) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63671       };
63672     } catch (...) {
63673       {
63674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63675       };
63676     }
63677   }
63678
63679   jresult = (void *)result;
63680   return jresult;
63681 }
63682
63683
63684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63685   void * jresult ;
63686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63687   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63688
63689   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63690   {
63691     try {
63692       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63693     } catch (std::out_of_range& e) {
63694       {
63695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63696       };
63697     } catch (std::exception& e) {
63698       {
63699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63700       };
63701     } catch (Dali::DaliException e) {
63702       {
63703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63704       };
63705     } catch (...) {
63706       {
63707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63708       };
63709     }
63710   }
63711
63712   jresult = (void *)result;
63713   return jresult;
63714 }
63715
63716
63717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63719   int arg2 ;
63720   SwigDirector_ViewImpl *darg = 0;
63721
63722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63723   arg2 = (int)jarg2;
63724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63725   if(!darg) {
63726     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63727     return;
63728   }
63729   {
63730     try {
63731       if(darg) {
63732         (darg)->OnStageConnection(arg2);
63733       }
63734     } catch (std::out_of_range& e) {
63735       {
63736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63737       };
63738     } catch (std::exception& e) {
63739       {
63740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63741       };
63742     } catch (Dali::DaliException e) {
63743       {
63744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63745       };
63746     } catch (...) {
63747       {
63748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63749       };
63750     }
63751   }
63752
63753 }
63754
63755
63756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63758   int arg2 ;
63759   SwigDirector_ViewImpl *darg = 0;
63760
63761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63762   arg2 = (int)jarg2;
63763   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63764   if(!darg) {
63765     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63766     return;
63767   }
63768   {
63769     try {
63770       if(darg) {
63771         (darg)->OnStageConnectionSwigPublic(arg2);
63772       }
63773     } catch (std::out_of_range& e) {
63774       {
63775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63776       };
63777     } catch (std::exception& e) {
63778       {
63779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63780       };
63781     } catch (Dali::DaliException e) {
63782       {
63783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63784       };
63785     } catch (...) {
63786       {
63787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63788       };
63789     }
63790   }
63791
63792 }
63793
63794
63795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63797   SwigDirector_ViewImpl *darg = 0;
63798
63799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63801   if(!darg) {
63802     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63803     return;
63804   }
63805   {
63806     try {
63807       if(darg) {
63808         (darg)->OnStageDisconnection();
63809       }
63810     } catch (std::out_of_range& e) {
63811       {
63812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63813       };
63814     } catch (std::exception& e) {
63815       {
63816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63817       };
63818     } catch (Dali::DaliException e) {
63819       {
63820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63821       };
63822     } catch (...) {
63823       {
63824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63825       };
63826     }
63827   }
63828
63829 }
63830
63831
63832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63834   SwigDirector_ViewImpl *darg = 0;
63835
63836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63837   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63838   if(!darg) {
63839     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63840     return;
63841   }
63842   {
63843     try {
63844       if(darg) {
63845         (darg)->OnStageDisconnectionSwigPublic();
63846       }
63847     } catch (std::out_of_range& e) {
63848       {
63849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63850       };
63851     } catch (std::exception& e) {
63852       {
63853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63854       };
63855     } catch (Dali::DaliException e) {
63856       {
63857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63862       };
63863     }
63864   }
63865
63866 }
63867
63868
63869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63871   Dali::Actor *arg2 = 0 ;
63872   SwigDirector_ViewImpl *darg = 0;
63873
63874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63875   arg2 = (Dali::Actor *)jarg2;
63876   if (!arg2) {
63877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63878     return ;
63879   }
63880   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63881   if(!darg) {
63882     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63883     return;
63884   }
63885   {
63886     try {
63887       if(darg) {
63888         (darg)->OnChildAdd(*arg2);
63889       }
63890     } catch (std::out_of_range& e) {
63891       {
63892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63893       };
63894     } catch (std::exception& e) {
63895       {
63896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63897       };
63898     } catch (Dali::DaliException e) {
63899       {
63900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63901       };
63902     } catch (...) {
63903       {
63904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63905       };
63906     }
63907   }
63908
63909 }
63910
63911
63912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63914   Dali::Actor *arg2 = 0 ;
63915   SwigDirector_ViewImpl *darg = 0;
63916
63917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63918   arg2 = (Dali::Actor *)jarg2;
63919   if (!arg2) {
63920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63921     return ;
63922   }
63923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63924   if(!darg) {
63925     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63926     return;
63927   }
63928   {
63929     try {
63930       if(darg) {
63931           (darg)->OnChildAddSwigPublic(*arg2);
63932       }
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63940       };
63941     } catch (Dali::DaliException e) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63944       };
63945     } catch (...) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63948       };
63949     }
63950   }
63951
63952 }
63953
63954
63955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63957   Dali::Actor *arg2 = 0 ;
63958   SwigDirector_ViewImpl *darg = 0;
63959
63960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63961   arg2 = (Dali::Actor *)jarg2;
63962   if (!arg2) {
63963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63964     return ;
63965   }
63966   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63967   if(!darg) {
63968     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63969     return;
63970   }
63971   {
63972     try {
63973       if(darg) {
63974         (darg)->OnChildRemove(*arg2);
63975       }
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63983       };
63984     } catch (Dali::DaliException e) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63987       };
63988     } catch (...) {
63989       {
63990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63991       };
63992     }
63993   }
63994
63995 }
63996
63997
63998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64000   Dali::Actor *arg2 = 0 ;
64001   SwigDirector_ViewImpl *darg = 0;
64002
64003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64004   arg2 = (Dali::Actor *)jarg2;
64005   if (!arg2) {
64006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64007     return ;
64008   }
64009   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64010   if(!darg) {
64011     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64012     return;
64013   }
64014   {
64015     try {
64016       if(darg) {
64017         (darg)->OnChildRemoveSwigPublic(*arg2);
64018       }
64019     } catch (std::out_of_range& e) {
64020       {
64021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64022       };
64023     } catch (std::exception& e) {
64024       {
64025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64026       };
64027     } catch (Dali::DaliException e) {
64028       {
64029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64030       };
64031     } catch (...) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64034       };
64035     }
64036   }
64037
64038 }
64039
64040
64041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64043   Dali::Property::Index arg2 ;
64044   Dali::Property::Value arg3 ;
64045   Dali::Property::Value *argp3 ;
64046   SwigDirector_ViewImpl *darg = 0;
64047
64048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64049   arg2 = (Dali::Property::Index)jarg2;
64050   argp3 = (Dali::Property::Value *)jarg3;
64051   if (!argp3) {
64052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64053     return ;
64054   }
64055   arg3 = *argp3;
64056   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64057   if (!darg) {
64058     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64059     return;
64060   }
64061   {
64062     try {
64063       (darg)->OnPropertySet(arg2,arg3);
64064     } catch (std::out_of_range& e) {
64065       {
64066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64067       };
64068     } catch (std::exception& e) {
64069       {
64070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64071       };
64072     } catch (Dali::DaliException e) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64075       };
64076     } catch (...) {
64077       {
64078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64079       };
64080     }
64081   }
64082
64083 }
64084
64085
64086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64088   Dali::Property::Index arg2 ;
64089   Dali::Property::Value arg3 ;
64090   Dali::Property::Value *argp3 ;
64091   SwigDirector_ViewImpl *darg = 0;
64092
64093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64094   arg2 = (Dali::Property::Index)jarg2;
64095   argp3 = (Dali::Property::Value *)jarg3;
64096   if (!argp3) {
64097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64098     return ;
64099   }
64100   arg3 = *argp3;
64101   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64102   if (!darg) {
64103     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64104     return;
64105   }
64106   {
64107     try {
64108       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64109     } catch (std::out_of_range& e) {
64110       {
64111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64112       };
64113     } catch (std::exception& e) {
64114       {
64115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64116       };
64117     } catch (Dali::DaliException e) {
64118       {
64119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64120       };
64121     } catch (...) {
64122       {
64123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64124       };
64125     }
64126   }
64127
64128 }
64129
64130
64131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64133   Dali::Vector3 *arg2 = 0 ;
64134   SwigDirector_ViewImpl *darg = 0;
64135
64136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64137   arg2 = (Dali::Vector3 *)jarg2;
64138   if (!arg2) {
64139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64140     return ;
64141   }
64142   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64143   if (!darg) {
64144     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64145     return;
64146   }
64147   {
64148     try {
64149       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64150     } catch (std::out_of_range& e) {
64151       {
64152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64153       };
64154     } catch (std::exception& e) {
64155       {
64156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64157       };
64158     } catch (Dali::DaliException e) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64161       };
64162     } catch (...) {
64163       {
64164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64165       };
64166     }
64167   }
64168
64169 }
64170
64171
64172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64174   Dali::Vector3 *arg2 = 0 ;
64175   SwigDirector_ViewImpl *darg = 0;
64176
64177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64178   arg2 = (Dali::Vector3 *)jarg2;
64179   if (!arg2) {
64180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64181     return ;
64182   }
64183   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64184   if (!darg) {
64185     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64186     return;
64187   }
64188   {
64189     try {
64190       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64191     } catch (std::out_of_range& e) {
64192       {
64193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64194       };
64195     } catch (std::exception& e) {
64196       {
64197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64198       };
64199     } catch (Dali::DaliException e) {
64200       {
64201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64202       };
64203     } catch (...) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64206       };
64207     }
64208   }
64209
64210 }
64211
64212
64213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64215   Dali::Animation *arg2 = 0 ;
64216   Dali::Vector3 *arg3 = 0 ;
64217   SwigDirector_ViewImpl *darg = 0;
64218
64219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64220   arg2 = (Dali::Animation *)jarg2;
64221   if (!arg2) {
64222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64223     return ;
64224   }
64225   arg3 = (Dali::Vector3 *)jarg3;
64226   if (!arg3) {
64227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64228     return ;
64229   }
64230   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64231   if (!darg) {
64232     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64233     return;
64234   }
64235   {
64236     try {
64237       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64238     } catch (std::out_of_range& e) {
64239       {
64240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64241       };
64242     } catch (std::exception& e) {
64243       {
64244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64245       };
64246     } catch (Dali::DaliException e) {
64247       {
64248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64249       };
64250     } catch (...) {
64251       {
64252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64253       };
64254     }
64255   }
64256
64257 }
64258
64259
64260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64262   Dali::Animation *arg2 = 0 ;
64263   Dali::Vector3 *arg3 = 0 ;
64264   SwigDirector_ViewImpl *darg = 0;
64265
64266   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64267   arg2 = (Dali::Animation *)jarg2;
64268   if (!arg2) {
64269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64270     return ;
64271   }
64272   arg3 = (Dali::Vector3 *)jarg3;
64273   if (!arg3) {
64274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64275     return ;
64276   }
64277   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64278   if (!darg) {
64279     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64280     return;
64281   }
64282   {
64283     try {
64284       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64285     } catch (std::out_of_range& e) {
64286       {
64287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64288       };
64289     } catch (std::exception& e) {
64290       {
64291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64292       };
64293     } catch (Dali::DaliException e) {
64294       {
64295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64296       };
64297     } catch (...) {
64298       {
64299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64300       };
64301     }
64302   }
64303
64304 }
64305
64306
64307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64308   unsigned int jresult ;
64309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64310   Dali::TouchEvent *arg2 = 0 ;
64311   SwigDirector_ViewImpl *darg = 0;
64312   bool result;
64313
64314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64315   arg2 = (Dali::TouchEvent *)jarg2;
64316   if (!arg2) {
64317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64318     return 0;
64319   }
64320   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64321   if (!darg) {
64322     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64323     return 0;
64324   }
64325   {
64326     try {
64327       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64328     } catch (std::out_of_range& e) {
64329       {
64330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64331       };
64332     } catch (std::exception& e) {
64333       {
64334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64335       };
64336     } catch (Dali::DaliException e) {
64337       {
64338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64339       };
64340     } catch (...) {
64341       {
64342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64343       };
64344     }
64345   }
64346
64347   jresult = result;
64348   return jresult;
64349 }
64350
64351
64352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64353   unsigned int jresult ;
64354   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64355   Dali::TouchEvent *arg2 = 0 ;
64356   SwigDirector_ViewImpl *darg = 0;
64357   bool result;
64358
64359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64360   arg2 = (Dali::TouchEvent *)jarg2;
64361   if (!arg2) {
64362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64363     return 0;
64364   }
64365   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64366   if (!darg) {
64367     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64368     return 0;
64369   }
64370   {
64371     try {
64372       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64373     } catch (std::out_of_range& e) {
64374       {
64375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64376       };
64377     } catch (std::exception& e) {
64378       {
64379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64380       };
64381     } catch (Dali::DaliException e) {
64382       {
64383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64384       };
64385     } catch (...) {
64386       {
64387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64388       };
64389     }
64390   }
64391
64392   jresult = result;
64393   return jresult;
64394 }
64395
64396
64397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64398   unsigned int jresult ;
64399   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64400   Dali::HoverEvent *arg2 = 0 ;
64401   SwigDirector_ViewImpl *darg = 0;
64402   bool result;
64403
64404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64405   arg2 = (Dali::HoverEvent *)jarg2;
64406   if (!arg2) {
64407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64408     return 0;
64409   }
64410   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64411   if (!darg) {
64412     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64413     return 0;
64414   }
64415   {
64416     try {
64417       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64418     } catch (std::out_of_range& e) {
64419       {
64420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64421       };
64422     } catch (std::exception& e) {
64423       {
64424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64425       };
64426     } catch (Dali::DaliException e) {
64427       {
64428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64429       };
64430     } catch (...) {
64431       {
64432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64433       };
64434     }
64435   }
64436
64437   jresult = result;
64438   return jresult;
64439 }
64440
64441
64442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64443   unsigned int jresult ;
64444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64445   Dali::HoverEvent *arg2 = 0 ;
64446   SwigDirector_ViewImpl *darg = 0;
64447   bool result;
64448
64449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64450   arg2 = (Dali::HoverEvent *)jarg2;
64451   if (!arg2) {
64452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64453     return 0;
64454   }
64455   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64456   if (!darg) {
64457     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64458     return 0;
64459   }
64460   {
64461     try {
64462       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64463     } catch (std::out_of_range& e) {
64464       {
64465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64466       };
64467     } catch (std::exception& e) {
64468       {
64469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64470       };
64471     } catch (Dali::DaliException e) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64474       };
64475     } catch (...) {
64476       {
64477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64478       };
64479     }
64480   }
64481
64482   jresult = result;
64483   return jresult;
64484 }
64485
64486
64487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64488   unsigned int jresult ;
64489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64490   Dali::KeyEvent *arg2 = 0 ;
64491   SwigDirector_ViewImpl *darg = 0;
64492   bool result;
64493
64494   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64495   arg2 = (Dali::KeyEvent *)jarg2;
64496   if (!arg2) {
64497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64498     return 0;
64499   }
64500   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64501   if (!darg) {
64502     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64503     return 0;
64504   }
64505   {
64506     try {
64507       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64508     } catch (std::out_of_range& e) {
64509       {
64510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64511       };
64512     } catch (std::exception& e) {
64513       {
64514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64515       };
64516     } catch (Dali::DaliException e) {
64517       {
64518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64519       };
64520     } catch (...) {
64521       {
64522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64523       };
64524     }
64525   }
64526
64527   jresult = result;
64528   return jresult;
64529 }
64530
64531
64532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64533   unsigned int jresult ;
64534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64535   Dali::KeyEvent *arg2 = 0 ;
64536   SwigDirector_ViewImpl *darg = 0;
64537   bool result;
64538
64539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64540   arg2 = (Dali::KeyEvent *)jarg2;
64541   if (!arg2) {
64542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64543     return 0;
64544   }
64545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64546   if (!darg) {
64547     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64548     return 0;
64549   }
64550   {
64551     try {
64552       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64553     } catch (std::out_of_range& e) {
64554       {
64555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64556       };
64557     } catch (std::exception& e) {
64558       {
64559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64560       };
64561     } catch (Dali::DaliException e) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64564       };
64565     } catch (...) {
64566       {
64567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64568       };
64569     }
64570   }
64571
64572   jresult = result;
64573   return jresult;
64574 }
64575
64576
64577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64578   unsigned int jresult ;
64579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64580   Dali::WheelEvent *arg2 = 0 ;
64581   SwigDirector_ViewImpl *darg = 0;
64582   bool result;
64583
64584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64585   arg2 = (Dali::WheelEvent *)jarg2;
64586   if (!arg2) {
64587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64588     return 0;
64589   }
64590   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64591   if (!darg) {
64592     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64593     return 0;
64594   }
64595   {
64596     try {
64597       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64598     } catch (std::out_of_range& e) {
64599       {
64600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64601       };
64602     } catch (std::exception& e) {
64603       {
64604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64605       };
64606     } catch (Dali::DaliException e) {
64607       {
64608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64609       };
64610     } catch (...) {
64611       {
64612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64613       };
64614     }
64615   }
64616
64617   jresult = result;
64618   return jresult;
64619 }
64620
64621
64622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64623   unsigned int jresult ;
64624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64625   Dali::WheelEvent *arg2 = 0 ;
64626   SwigDirector_ViewImpl *darg = 0;
64627   bool result;
64628
64629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64630   arg2 = (Dali::WheelEvent *)jarg2;
64631   if (!arg2) {
64632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64633     return 0;
64634   }
64635   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64636   if (!darg) {
64637     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64638     return 0;
64639   }
64640   {
64641     try {
64642       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64643     } catch (std::out_of_range& e) {
64644       {
64645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64646       };
64647     } catch (std::exception& e) {
64648       {
64649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64650       };
64651     } catch (Dali::DaliException e) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64654       };
64655     } catch (...) {
64656       {
64657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64658       };
64659     }
64660   }
64661
64662   jresult = result;
64663   return jresult;
64664 }
64665
64666
64667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64669   Dali::Vector2 *arg2 = 0 ;
64670   Dali::RelayoutContainer *arg3 = 0 ;
64671   SwigDirector_ViewImpl *darg = 0;
64672
64673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64674   arg2 = (Dali::Vector2 *)jarg2;
64675   if (!arg2) {
64676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64677     return ;
64678   }
64679   arg3 = (Dali::RelayoutContainer *)jarg3;
64680   if (!arg3) {
64681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64682     return ;
64683   }
64684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64685   if (!darg) {
64686     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64687     return;
64688   }
64689   {
64690     try {
64691       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64692     } catch (std::out_of_range& e) {
64693       {
64694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64695       };
64696     } catch (std::exception& e) {
64697       {
64698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64699       };
64700     } catch (Dali::DaliException e) {
64701       {
64702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64703       };
64704     } catch (...) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64707       };
64708     }
64709   }
64710
64711 }
64712
64713
64714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64716   Dali::Vector2 *arg2 = 0 ;
64717   Dali::RelayoutContainer *arg3 = 0 ;
64718   SwigDirector_ViewImpl *darg = 0;
64719
64720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64721   arg2 = (Dali::Vector2 *)jarg2;
64722   if (!arg2) {
64723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64724     return ;
64725   }
64726   arg3 = (Dali::RelayoutContainer *)jarg3;
64727   if (!arg3) {
64728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64729     return ;
64730   }
64731   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64732   if (!darg) {
64733     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64734     return;
64735   }
64736   {
64737     try {
64738       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64739     } catch (std::out_of_range& e) {
64740       {
64741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64742       };
64743     } catch (std::exception& e) {
64744       {
64745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64746       };
64747     } catch (Dali::DaliException e) {
64748       {
64749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64750       };
64751     } catch (...) {
64752       {
64753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64754       };
64755     }
64756   }
64757
64758 }
64759
64760
64761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64763   Dali::ResizePolicy::Type arg2 ;
64764   Dali::Dimension::Type arg3 ;
64765   SwigDirector_ViewImpl *darg = 0;
64766
64767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64768   arg2 = (Dali::ResizePolicy::Type)jarg2;
64769   arg3 = (Dali::Dimension::Type)jarg3;
64770   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64771   if (!darg) {
64772     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64773     return;
64774   }
64775   {
64776     try {
64777       (darg)->OnSetResizePolicy(arg2,arg3);
64778     } catch (std::out_of_range& e) {
64779       {
64780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64781       };
64782     } catch (std::exception& e) {
64783       {
64784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64785       };
64786     } catch (Dali::DaliException e) {
64787       {
64788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64789       };
64790     } catch (...) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64793       };
64794     }
64795   }
64796
64797 }
64798
64799
64800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64802   Dali::ResizePolicy::Type arg2 ;
64803   Dali::Dimension::Type arg3 ;
64804   SwigDirector_ViewImpl *darg = 0;
64805
64806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64807   arg2 = (Dali::ResizePolicy::Type)jarg2;
64808   arg3 = (Dali::Dimension::Type)jarg3;
64809   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64810   if (!darg) {
64811     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64812     return;
64813   }
64814   {
64815     try {
64816       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64817     } catch (std::out_of_range& e) {
64818       {
64819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64820       };
64821     } catch (std::exception& e) {
64822       {
64823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64824       };
64825     } catch (Dali::DaliException e) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64828       };
64829     } catch (...) {
64830       {
64831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64832       };
64833     }
64834   }
64835
64836 }
64837
64838
64839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64840   void * jresult ;
64841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64842   SwigDirector_ViewImpl *darg = 0;
64843   Dali::Vector3 result;
64844
64845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64847   if (!darg) {
64848     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64849     return 0;
64850   }
64851   {
64852     try {
64853       result = (darg)->GetNaturalSize();
64854     } catch (std::out_of_range& e) {
64855       {
64856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64857       };
64858     } catch (std::exception& e) {
64859       {
64860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64861       };
64862     } catch (Dali::DaliException e) {
64863       {
64864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64865       };
64866     } catch (...) {
64867       {
64868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64869       };
64870     }
64871   }
64872
64873   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64874   return jresult;
64875 }
64876
64877
64878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64879   void * jresult ;
64880   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64881   SwigDirector_ViewImpl *darg = 0;
64882   Dali::Vector3 result;
64883
64884   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64885   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64886   if (!darg) {
64887     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64888     return 0;
64889   }
64890   {
64891     try {
64892       result = (darg)->GetNaturalSizeSwigPublic();
64893     } catch (std::out_of_range& e) {
64894       {
64895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64896       };
64897     } catch (std::exception& e) {
64898       {
64899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64900       };
64901     } catch (Dali::DaliException e) {
64902       {
64903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64904       };
64905     } catch (...) {
64906       {
64907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64908       };
64909     }
64910   }
64911
64912   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64913   return jresult;
64914 }
64915
64916
64917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64918   float jresult ;
64919   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64920   Dali::Actor *arg2 = 0 ;
64921   Dali::Dimension::Type arg3 ;
64922   SwigDirector_ViewImpl *darg = 0;
64923   float result;
64924
64925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64926   arg2 = (Dali::Actor *)jarg2;
64927   if (!arg2) {
64928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64929     return 0;
64930   }
64931   arg3 = (Dali::Dimension::Type)jarg3;
64932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64933   if (!darg) {
64934     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64935     return 0;
64936   }
64937   {
64938     try {
64939       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64940     } catch (std::out_of_range& e) {
64941       {
64942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64943       };
64944     } catch (std::exception& e) {
64945       {
64946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64947       };
64948     } catch (Dali::DaliException e) {
64949       {
64950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64951       };
64952     } catch (...) {
64953       {
64954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64955       };
64956     }
64957   }
64958
64959   jresult = result;
64960   return jresult;
64961 }
64962
64963
64964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64965   float jresult ;
64966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64967   Dali::Actor *arg2 = 0 ;
64968   Dali::Dimension::Type arg3 ;
64969   SwigDirector_ViewImpl *darg = 0;
64970   float result;
64971
64972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64973   arg2 = (Dali::Actor *)jarg2;
64974   if (!arg2) {
64975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64976     return 0;
64977   }
64978   arg3 = (Dali::Dimension::Type)jarg3;
64979   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64980   if (!darg) {
64981     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64982     return 0;
64983   }
64984   {
64985     try {
64986       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64987     } catch (std::out_of_range& e) {
64988       {
64989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64990       };
64991     } catch (std::exception& e) {
64992       {
64993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64994       };
64995     } catch (Dali::DaliException e) {
64996       {
64997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64998       };
64999     } catch (...) {
65000       {
65001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65002       };
65003     }
65004   }
65005
65006   jresult = result;
65007   return jresult;
65008 }
65009
65010
65011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65012   float jresult ;
65013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65014   float arg2 ;
65015   SwigDirector_ViewImpl *darg = 0;
65016   float result;
65017
65018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65019   arg2 = (float)jarg2;
65020   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65021   if (!darg) {
65022     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65023     return 0;
65024   }
65025   {
65026     try {
65027       result = (float)(darg)->GetHeightForWidth(arg2);
65028     } catch (std::out_of_range& e) {
65029       {
65030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65031       };
65032     } catch (std::exception& e) {
65033       {
65034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65035       };
65036     } catch (Dali::DaliException e) {
65037       {
65038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65039       };
65040     } catch (...) {
65041       {
65042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65043       };
65044     }
65045   }
65046
65047   jresult = result;
65048   return jresult;
65049 }
65050
65051
65052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65053   float jresult ;
65054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65055   float arg2 ;
65056   SwigDirector_ViewImpl *darg = 0;
65057   float result;
65058
65059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65060   arg2 = (float)jarg2;
65061   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65062   if (!darg) {
65063     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65064     return 0;
65065   }
65066   {
65067     try {
65068       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65069     } catch (std::out_of_range& e) {
65070       {
65071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65072       };
65073     } catch (std::exception& e) {
65074       {
65075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65076       };
65077     } catch (Dali::DaliException e) {
65078       {
65079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65080       };
65081     } catch (...) {
65082       {
65083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65084       };
65085     }
65086   }
65087
65088   jresult = result;
65089   return jresult;
65090 }
65091
65092
65093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65094   float jresult ;
65095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65096   float arg2 ;
65097   SwigDirector_ViewImpl *darg = 0;
65098   float result;
65099
65100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65101   arg2 = (float)jarg2;
65102   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65103   if (!darg) {
65104     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65105     return 0;
65106   }
65107   {
65108     try {
65109       result = (float)(darg)->GetWidthForHeight(arg2);
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65117       };
65118     } catch (Dali::DaliException e) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65121       };
65122     } catch (...) {
65123       {
65124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65125       };
65126     }
65127   }
65128
65129   jresult = result;
65130   return jresult;
65131 }
65132
65133
65134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65135   float jresult ;
65136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65137   float arg2 ;
65138   SwigDirector_ViewImpl *darg = 0;
65139   float result;
65140
65141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65142   arg2 = (float)jarg2;
65143   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65144   if (!darg) {
65145     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65146     return 0;
65147   }
65148   {
65149     try {
65150       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65151     } catch (std::out_of_range& e) {
65152       {
65153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65154       };
65155     } catch (std::exception& e) {
65156       {
65157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65158       };
65159     } catch (Dali::DaliException e) {
65160       {
65161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65162       };
65163     } catch (...) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65166       };
65167     }
65168   }
65169
65170   jresult = result;
65171   return jresult;
65172 }
65173
65174
65175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65176   unsigned int jresult ;
65177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65178   Dali::Dimension::Type arg2 ;
65179   SwigDirector_ViewImpl *darg = 0;
65180   bool result;
65181
65182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65183   arg2 = (Dali::Dimension::Type)jarg2;
65184   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65185   if (!darg) {
65186     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65187     return 0;
65188   }
65189   {
65190     try {
65191       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65192     } catch (std::out_of_range& e) {
65193       {
65194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (std::exception& e) {
65197       {
65198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65199       };
65200     } catch (Dali::DaliException e) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65203       };
65204     } catch (...) {
65205       {
65206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65207       };
65208     }
65209   }
65210
65211   jresult = result;
65212   return jresult;
65213 }
65214
65215
65216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65217   unsigned int jresult ;
65218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65219   Dali::Dimension::Type arg2 ;
65220   SwigDirector_ViewImpl *darg = 0;
65221   bool result;
65222
65223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65224   arg2 = (Dali::Dimension::Type)jarg2;
65225   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65226   if (!darg) {
65227     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65228     return 0;
65229   }
65230   {
65231     try {
65232       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65233     } catch (std::out_of_range& e) {
65234       {
65235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65236       };
65237     } catch (std::exception& e) {
65238       {
65239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65240       };
65241     } catch (Dali::DaliException e) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65244       };
65245     } catch (...) {
65246       {
65247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65248       };
65249     }
65250   }
65251
65252   jresult = result;
65253   return jresult;
65254 }
65255
65256
65257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65258   unsigned int jresult ;
65259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65260   SwigDirector_ViewImpl *darg = 0;
65261   bool result;
65262
65263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65264   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65265   if (!darg) {
65266     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65267     return 0;
65268   }
65269   {
65270     try {
65271       result = (bool)(darg)->RelayoutDependentOnChildren();
65272     } catch (std::out_of_range& e) {
65273       {
65274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65275       };
65276     } catch (std::exception& e) {
65277       {
65278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65279       };
65280     } catch (Dali::DaliException e) {
65281       {
65282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65283       };
65284     } catch (...) {
65285       {
65286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65287       };
65288     }
65289   }
65290
65291   jresult = result;
65292   return jresult;
65293 }
65294
65295
65296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65297   unsigned int jresult ;
65298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65299   SwigDirector_ViewImpl *darg = 0;
65300   bool result;
65301
65302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65303   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65304   if (!darg) {
65305     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65306     return 0;
65307   }
65308   {
65309     try {
65310       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65311     } catch (std::out_of_range& e) {
65312       {
65313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (std::exception& e) {
65316       {
65317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65318       };
65319     } catch (Dali::DaliException e) {
65320       {
65321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65322       };
65323     } catch (...) {
65324       {
65325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65326       };
65327     }
65328   }
65329
65330   jresult = result;
65331   return jresult;
65332 }
65333
65334
65335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65337   Dali::Dimension::Type arg2 ;
65338   SwigDirector_ViewImpl *darg = 0;
65339
65340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65341   arg2 = (Dali::Dimension::Type)jarg2;
65342   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65343   if (!darg) {
65344     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65345     return;
65346   }
65347   {
65348     try {
65349       (darg)->OnCalculateRelayoutSize(arg2);
65350     } catch (std::out_of_range& e) {
65351       {
65352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65353       };
65354     } catch (std::exception& e) {
65355       {
65356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65357       };
65358     } catch (Dali::DaliException e) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65361       };
65362     } catch (...) {
65363       {
65364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65365       };
65366     }
65367   }
65368
65369 }
65370
65371
65372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65374   Dali::Dimension::Type arg2 ;
65375   SwigDirector_ViewImpl *darg = 0;
65376
65377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65378   arg2 = (Dali::Dimension::Type)jarg2;
65379   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65380   if (!darg) {
65381     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65382     return;
65383   }
65384   {
65385     try {
65386       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65387     } catch (std::out_of_range& e) {
65388       {
65389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65390       };
65391     } catch (std::exception& e) {
65392       {
65393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65394       };
65395     } catch (Dali::DaliException e) {
65396       {
65397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65398       };
65399     } catch (...) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65402       };
65403     }
65404   }
65405
65406 }
65407
65408
65409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65411   float arg2 ;
65412   Dali::Dimension::Type arg3 ;
65413   SwigDirector_ViewImpl *darg = 0;
65414
65415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65416   arg2 = (float)jarg2;
65417   arg3 = (Dali::Dimension::Type)jarg3;
65418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65419   if (!darg) {
65420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65421     return;
65422   }
65423   {
65424     try {
65425       (darg)->OnLayoutNegotiated(arg2,arg3);
65426     } catch (std::out_of_range& e) {
65427       {
65428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65429       };
65430     } catch (std::exception& e) {
65431       {
65432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65433       };
65434     } catch (Dali::DaliException e) {
65435       {
65436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65437       };
65438     } catch (...) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65441       };
65442     }
65443   }
65444
65445 }
65446
65447
65448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65450   float arg2 ;
65451   Dali::Dimension::Type arg3 ;
65452   SwigDirector_ViewImpl *darg = 0;
65453
65454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65455   arg2 = (float)jarg2;
65456   arg3 = (Dali::Dimension::Type)jarg3;
65457   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65458   if (!darg) {
65459     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65460     return;
65461   }
65462   {
65463     try {
65464       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65465     } catch (std::out_of_range& e) {
65466       {
65467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65468       };
65469     } catch (std::exception& e) {
65470       {
65471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65472       };
65473     } catch (Dali::DaliException e) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65476       };
65477     } catch (...) {
65478       {
65479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65480       };
65481     }
65482   }
65483
65484 }
65485
65486
65487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65488   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65489
65490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65491   {
65492     try {
65493       (arg1)->OnInitialize();
65494     } catch (std::out_of_range& e) {
65495       {
65496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65497       };
65498     } catch (std::exception& e) {
65499       {
65500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65501       };
65502     } catch (Dali::DaliException e) {
65503       {
65504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65505       };
65506     } catch (...) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65509       };
65510     }
65511   }
65512
65513 }
65514
65515
65516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65518
65519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65520   {
65521     try {
65522       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65523     } catch (std::out_of_range& e) {
65524       {
65525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65526       };
65527     } catch (std::exception& e) {
65528       {
65529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65530       };
65531     } catch (Dali::DaliException e) {
65532       {
65533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65534       };
65535     } catch (...) {
65536       {
65537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65538       };
65539     }
65540   }
65541
65542 }
65543
65544
65545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65547   Dali::Actor *arg2 = 0 ;
65548
65549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65550   arg2 = (Dali::Actor *)jarg2;
65551   if (!arg2) {
65552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65553     return ;
65554   }
65555   {
65556     try {
65557       (arg1)->OnControlChildAdd(*arg2);
65558     } catch (std::out_of_range& e) {
65559       {
65560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65561       };
65562     } catch (std::exception& e) {
65563       {
65564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65565       };
65566     } catch (Dali::DaliException e) {
65567       {
65568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65569       };
65570     } catch (...) {
65571       {
65572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65573       };
65574     }
65575   }
65576
65577 }
65578
65579
65580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65582   Dali::Actor *arg2 = 0 ;
65583
65584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65585   arg2 = (Dali::Actor *)jarg2;
65586   if (!arg2) {
65587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65588     return ;
65589   }
65590   {
65591     try {
65592       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65593     } catch (std::out_of_range& e) {
65594       {
65595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65596       };
65597     } catch (std::exception& e) {
65598       {
65599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65600       };
65601     } catch (Dali::DaliException e) {
65602       {
65603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65604       };
65605     } catch (...) {
65606       {
65607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65608       };
65609     }
65610   }
65611
65612 }
65613
65614
65615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65617   Dali::Actor *arg2 = 0 ;
65618
65619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65620   arg2 = (Dali::Actor *)jarg2;
65621   if (!arg2) {
65622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65623     return ;
65624   }
65625   {
65626     try {
65627       (arg1)->OnControlChildRemove(*arg2);
65628     } catch (std::out_of_range& e) {
65629       {
65630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65631       };
65632     } catch (std::exception& e) {
65633       {
65634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65635       };
65636     } catch (Dali::DaliException e) {
65637       {
65638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65639       };
65640     } catch (...) {
65641       {
65642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65643       };
65644     }
65645   }
65646
65647 }
65648
65649
65650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65652   Dali::Actor *arg2 = 0 ;
65653
65654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65655   arg2 = (Dali::Actor *)jarg2;
65656   if (!arg2) {
65657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65658     return ;
65659   }
65660   {
65661     try {
65662       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65663     } catch (std::out_of_range& e) {
65664       {
65665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65666       };
65667     } catch (std::exception& e) {
65668       {
65669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65670       };
65671     } catch (Dali::DaliException e) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65674       };
65675     } catch (...) {
65676       {
65677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65678       };
65679     }
65680   }
65681
65682 }
65683
65684
65685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65687   Dali::Toolkit::StyleManager arg2 ;
65688   Dali::StyleChange::Type arg3 ;
65689   Dali::Toolkit::StyleManager *argp2 ;
65690
65691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65692   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65693   if (!argp2) {
65694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65695     return ;
65696   }
65697   arg2 = *argp2;
65698   arg3 = (Dali::StyleChange::Type)jarg3;
65699   {
65700     try {
65701       (arg1)->OnStyleChange(arg2,arg3);
65702     } catch (std::out_of_range& e) {
65703       {
65704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65705       };
65706     } catch (std::exception& e) {
65707       {
65708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65709       };
65710     } catch (Dali::DaliException e) {
65711       {
65712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65713       };
65714     } catch (...) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65717       };
65718     }
65719   }
65720
65721 }
65722
65723
65724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65726   Dali::Toolkit::StyleManager arg2 ;
65727   Dali::StyleChange::Type arg3 ;
65728   Dali::Toolkit::StyleManager *argp2 ;
65729
65730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65731   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65732   if (!argp2) {
65733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65734     return ;
65735   }
65736   arg2 = *argp2;
65737   arg3 = (Dali::StyleChange::Type)jarg3;
65738   {
65739     try {
65740       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65741     } catch (std::out_of_range& e) {
65742       {
65743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65744       };
65745     } catch (std::exception& e) {
65746       {
65747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65748       };
65749     } catch (Dali::DaliException e) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65752       };
65753     } catch (...) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65756       };
65757     }
65758   }
65759
65760 }
65761
65762
65763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65764   unsigned int jresult ;
65765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65766   bool result;
65767
65768   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65769   {
65770     try {
65771       result = (bool)(arg1)->OnAccessibilityActivated();
65772     } catch (std::out_of_range& e) {
65773       {
65774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (std::exception& e) {
65777       {
65778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65779       };
65780     } catch (Dali::DaliException e) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65783       };
65784     } catch (...) {
65785       {
65786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65787       };
65788     }
65789   }
65790
65791   jresult = result;
65792   return jresult;
65793 }
65794
65795
65796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65797   unsigned int jresult ;
65798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65799   bool result;
65800
65801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65802   {
65803     try {
65804       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65805     } catch (std::out_of_range& e) {
65806       {
65807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65808       };
65809     } catch (std::exception& e) {
65810       {
65811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65812       };
65813     } catch (Dali::DaliException e) {
65814       {
65815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65816       };
65817     } catch (...) {
65818       {
65819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65820       };
65821     }
65822   }
65823
65824   jresult = result;
65825   return jresult;
65826 }
65827
65828
65829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65830   unsigned int jresult ;
65831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65832   Dali::PanGesture arg2 ;
65833   Dali::PanGesture *argp2 ;
65834   bool result;
65835
65836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65837   argp2 = (Dali::PanGesture *)jarg2;
65838   if (!argp2) {
65839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65840     return 0;
65841   }
65842   arg2 = *argp2;
65843   {
65844     try {
65845       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65846     } catch (std::out_of_range& e) {
65847       {
65848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (std::exception& e) {
65851       {
65852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65853       };
65854     } catch (Dali::DaliException e) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65857       };
65858     } catch (...) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65861       };
65862     }
65863   }
65864
65865   jresult = result;
65866   return jresult;
65867 }
65868
65869
65870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65871   unsigned int jresult ;
65872   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65873   Dali::PanGesture arg2 ;
65874   Dali::PanGesture *argp2 ;
65875   bool result;
65876
65877   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65878   argp2 = (Dali::PanGesture *)jarg2;
65879   if (!argp2) {
65880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65881     return 0;
65882   }
65883   arg2 = *argp2;
65884   {
65885     try {
65886       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65887     } catch (std::out_of_range& e) {
65888       {
65889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65890       };
65891     } catch (std::exception& e) {
65892       {
65893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65894       };
65895     } catch (Dali::DaliException e) {
65896       {
65897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65898       };
65899     } catch (...) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65902       };
65903     }
65904   }
65905
65906   jresult = result;
65907   return jresult;
65908 }
65909
65910
65911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65912   unsigned int jresult ;
65913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65914   Dali::TouchEvent *arg2 = 0 ;
65915   bool result;
65916
65917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65918   arg2 = (Dali::TouchEvent *)jarg2;
65919   if (!arg2) {
65920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65921     return 0;
65922   }
65923   {
65924     try {
65925       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65926     } catch (std::out_of_range& e) {
65927       {
65928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65929       };
65930     } catch (std::exception& e) {
65931       {
65932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65933       };
65934     } catch (Dali::DaliException e) {
65935       {
65936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65937       };
65938     } catch (...) {
65939       {
65940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65941       };
65942     }
65943   }
65944
65945   jresult = result;
65946   return jresult;
65947 }
65948
65949
65950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65951   unsigned int jresult ;
65952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65953   Dali::TouchEvent *arg2 = 0 ;
65954   bool result;
65955
65956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65957   arg2 = (Dali::TouchEvent *)jarg2;
65958   if (!arg2) {
65959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65960     return 0;
65961   }
65962   {
65963     try {
65964       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65965     } catch (std::out_of_range& e) {
65966       {
65967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65968       };
65969     } catch (std::exception& e) {
65970       {
65971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65972       };
65973     } catch (Dali::DaliException e) {
65974       {
65975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65976       };
65977     } catch (...) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65980       };
65981     }
65982   }
65983
65984   jresult = result;
65985   return jresult;
65986 }
65987
65988
65989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65990   unsigned int jresult ;
65991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65992   bool arg2 ;
65993   bool result;
65994
65995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65996   arg2 = jarg2 ? true : false;
65997   {
65998     try {
65999       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66000     } catch (std::out_of_range& e) {
66001       {
66002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66003       };
66004     } catch (std::exception& e) {
66005       {
66006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66007       };
66008     } catch (Dali::DaliException e) {
66009       {
66010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66011       };
66012     } catch (...) {
66013       {
66014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66015       };
66016     }
66017   }
66018
66019   jresult = result;
66020   return jresult;
66021 }
66022
66023
66024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66025   unsigned int jresult ;
66026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66027   bool arg2 ;
66028   bool result;
66029
66030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66031   arg2 = jarg2 ? true : false;
66032   {
66033     try {
66034       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66035     } catch (std::out_of_range& e) {
66036       {
66037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66038       };
66039     } catch (std::exception& e) {
66040       {
66041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66042       };
66043     } catch (Dali::DaliException e) {
66044       {
66045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66046       };
66047     } catch (...) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66050       };
66051     }
66052   }
66053
66054   jresult = result;
66055   return jresult;
66056 }
66057
66058
66059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66060   unsigned int jresult ;
66061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66062   bool result;
66063
66064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66065   {
66066     try {
66067       result = (bool)(arg1)->OnAccessibilityZoom();
66068     } catch (std::out_of_range& e) {
66069       {
66070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (std::exception& e) {
66073       {
66074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66075       };
66076     } catch (Dali::DaliException e) {
66077       {
66078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66079       };
66080     } catch (...) {
66081       {
66082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66083       };
66084     }
66085   }
66086
66087   jresult = result;
66088   return jresult;
66089 }
66090
66091
66092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66093   unsigned int jresult ;
66094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66095   bool result;
66096
66097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66098   {
66099     try {
66100       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66101     } catch (std::out_of_range& e) {
66102       {
66103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66104       };
66105     } catch (std::exception& e) {
66106       {
66107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66108       };
66109     } catch (Dali::DaliException e) {
66110       {
66111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66112       };
66113     } catch (...) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66116       };
66117     }
66118   }
66119
66120   jresult = result;
66121   return jresult;
66122 }
66123
66124
66125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66127
66128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66129   {
66130     try {
66131       (arg1)->OnKeyInputFocusGained();
66132     } catch (std::out_of_range& e) {
66133       {
66134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66135       };
66136     } catch (std::exception& e) {
66137       {
66138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66139       };
66140     } catch (Dali::DaliException e) {
66141       {
66142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66143       };
66144     } catch (...) {
66145       {
66146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66147       };
66148     }
66149   }
66150
66151 }
66152
66153
66154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66156
66157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66158   {
66159     try {
66160       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66161     } catch (std::out_of_range& e) {
66162       {
66163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66164       };
66165     } catch (std::exception& e) {
66166       {
66167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66168       };
66169     } catch (Dali::DaliException e) {
66170       {
66171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66172       };
66173     } catch (...) {
66174       {
66175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66176       };
66177     }
66178   }
66179
66180 }
66181
66182
66183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66185
66186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66187   {
66188     try {
66189       (arg1)->OnKeyInputFocusLost();
66190     } catch (std::out_of_range& e) {
66191       {
66192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66193       };
66194     } catch (std::exception& e) {
66195       {
66196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66197       };
66198     } catch (Dali::DaliException e) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66201       };
66202     } catch (...) {
66203       {
66204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66205       };
66206     }
66207   }
66208
66209 }
66210
66211
66212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66214
66215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66216   {
66217     try {
66218       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66219     } catch (std::out_of_range& e) {
66220       {
66221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66222       };
66223     } catch (std::exception& e) {
66224       {
66225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66226       };
66227     } catch (Dali::DaliException e) {
66228       {
66229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66230       };
66231     } catch (...) {
66232       {
66233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66234       };
66235     }
66236   }
66237
66238 }
66239
66240
66241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66242   void * jresult ;
66243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66244   Dali::Actor arg2 ;
66245   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66246   bool arg4 ;
66247   Dali::Actor *argp2 ;
66248   Dali::Actor result;
66249
66250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66251   argp2 = (Dali::Actor *)jarg2;
66252   if (!argp2) {
66253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66254     return 0;
66255   }
66256   arg2 = *argp2;
66257   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66258   arg4 = jarg4 ? true : false;
66259   {
66260     try {
66261       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66262     } catch (std::out_of_range& e) {
66263       {
66264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66265       };
66266     } catch (std::exception& e) {
66267       {
66268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66269       };
66270     } catch (Dali::DaliException e) {
66271       {
66272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66273       };
66274     } catch (...) {
66275       {
66276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66277       };
66278     }
66279   }
66280
66281   jresult = new Dali::Actor((const Dali::Actor &)result);
66282   return jresult;
66283 }
66284
66285
66286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66287   void * jresult ;
66288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66289   Dali::Actor arg2 ;
66290   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66291   bool arg4 ;
66292   Dali::Actor *argp2 ;
66293   Dali::Actor result;
66294
66295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66296   argp2 = (Dali::Actor *)jarg2;
66297   if (!argp2) {
66298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66299     return 0;
66300   }
66301   arg2 = *argp2;
66302   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66303   arg4 = jarg4 ? true : false;
66304   {
66305     try {
66306       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66307     } catch (std::out_of_range& e) {
66308       {
66309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66310       };
66311     } catch (std::exception& e) {
66312       {
66313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66314       };
66315     } catch (Dali::DaliException e) {
66316       {
66317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66318       };
66319     } catch (...) {
66320       {
66321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66322       };
66323     }
66324   }
66325
66326   jresult = new Dali::Actor((const Dali::Actor &)result);
66327   return jresult;
66328 }
66329
66330
66331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66333   Dali::Actor arg2 ;
66334   Dali::Actor *argp2 ;
66335
66336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66337   argp2 = (Dali::Actor *)jarg2;
66338   if (!argp2) {
66339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66340     return ;
66341   }
66342   arg2 = *argp2;
66343   {
66344     try {
66345       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66346     } catch (std::out_of_range& e) {
66347       {
66348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66349       };
66350     } catch (std::exception& e) {
66351       {
66352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66353       };
66354     } catch (Dali::DaliException e) {
66355       {
66356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66357       };
66358     } catch (...) {
66359       {
66360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66361       };
66362     }
66363   }
66364
66365 }
66366
66367
66368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66370   Dali::Actor arg2 ;
66371   Dali::Actor *argp2 ;
66372
66373   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66374   argp2 = (Dali::Actor *)jarg2;
66375   if (!argp2) {
66376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66377     return ;
66378   }
66379   arg2 = *argp2;
66380   {
66381     try {
66382       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66383     } catch (std::out_of_range& e) {
66384       {
66385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66386       };
66387     } catch (std::exception& e) {
66388       {
66389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66390       };
66391     } catch (Dali::DaliException e) {
66392       {
66393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66394       };
66395     } catch (...) {
66396       {
66397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66398       };
66399     }
66400   }
66401
66402 }
66403
66404
66405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66406   unsigned int jresult ;
66407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66408   bool result;
66409
66410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66411   {
66412     try {
66413       result = (bool)(arg1)->OnKeyboardEnter();
66414     } catch (std::out_of_range& e) {
66415       {
66416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66417       };
66418     } catch (std::exception& e) {
66419       {
66420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66421       };
66422     } catch (Dali::DaliException e) {
66423       {
66424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66425       };
66426     } catch (...) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66429       };
66430     }
66431   }
66432
66433   jresult = result;
66434   return jresult;
66435 }
66436
66437
66438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66439   unsigned int jresult ;
66440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66441   bool result;
66442
66443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66444   {
66445     try {
66446       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66447     } catch (std::out_of_range& e) {
66448       {
66449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66450       };
66451     } catch (std::exception& e) {
66452       {
66453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66454       };
66455     } catch (Dali::DaliException e) {
66456       {
66457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66462       };
66463     }
66464   }
66465
66466   jresult = result;
66467   return jresult;
66468 }
66469
66470
66471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66473   Dali::PinchGesture *arg2 = 0 ;
66474
66475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66476   arg2 = (Dali::PinchGesture *)jarg2;
66477   if (!arg2) {
66478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66479     return ;
66480   }
66481   {
66482     try {
66483       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66484     } catch (std::out_of_range& e) {
66485       {
66486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66487       };
66488     } catch (std::exception& e) {
66489       {
66490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66491       };
66492     } catch (Dali::DaliException e) {
66493       {
66494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66495       };
66496     } catch (...) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66499       };
66500     }
66501   }
66502
66503 }
66504
66505
66506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66508   Dali::PinchGesture *arg2 = 0 ;
66509
66510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66511   arg2 = (Dali::PinchGesture *)jarg2;
66512   if (!arg2) {
66513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66514     return ;
66515   }
66516   {
66517     try {
66518       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66519     } catch (std::out_of_range& e) {
66520       {
66521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66522       };
66523     } catch (std::exception& e) {
66524       {
66525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66526       };
66527     } catch (Dali::DaliException e) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66530       };
66531     } catch (...) {
66532       {
66533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66534       };
66535     }
66536   }
66537
66538 }
66539
66540
66541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66543   Dali::PanGesture *arg2 = 0 ;
66544
66545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66546   arg2 = (Dali::PanGesture *)jarg2;
66547   if (!arg2) {
66548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66549     return ;
66550   }
66551   {
66552     try {
66553       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66554     } catch (std::out_of_range& e) {
66555       {
66556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66557       };
66558     } catch (std::exception& e) {
66559       {
66560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66561       };
66562     } catch (Dali::DaliException e) {
66563       {
66564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66565       };
66566     } catch (...) {
66567       {
66568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66569       };
66570     }
66571   }
66572
66573 }
66574
66575
66576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66578   Dali::PanGesture *arg2 = 0 ;
66579
66580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66581   arg2 = (Dali::PanGesture *)jarg2;
66582   if (!arg2) {
66583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66584     return ;
66585   }
66586   {
66587     try {
66588       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66589     } catch (std::out_of_range& e) {
66590       {
66591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66592       };
66593     } catch (std::exception& e) {
66594       {
66595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66596       };
66597     } catch (Dali::DaliException e) {
66598       {
66599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66600       };
66601     } catch (...) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66604       };
66605     }
66606   }
66607
66608 }
66609
66610
66611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66613   Dali::TapGesture *arg2 = 0 ;
66614
66615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66616   arg2 = (Dali::TapGesture *)jarg2;
66617   if (!arg2) {
66618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66619     return ;
66620   }
66621   {
66622     try {
66623       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66624     } catch (std::out_of_range& e) {
66625       {
66626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66627       };
66628     } catch (std::exception& e) {
66629       {
66630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66631       };
66632     } catch (Dali::DaliException e) {
66633       {
66634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66635       };
66636     } catch (...) {
66637       {
66638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66639       };
66640     }
66641   }
66642
66643 }
66644
66645
66646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66648   Dali::TapGesture *arg2 = 0 ;
66649
66650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66651   arg2 = (Dali::TapGesture *)jarg2;
66652   if (!arg2) {
66653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66654     return ;
66655   }
66656   {
66657     try {
66658       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66659     } catch (std::out_of_range& e) {
66660       {
66661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66662       };
66663     } catch (std::exception& e) {
66664       {
66665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66666       };
66667     } catch (Dali::DaliException e) {
66668       {
66669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66670       };
66671     } catch (...) {
66672       {
66673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66674       };
66675     }
66676   }
66677
66678 }
66679
66680
66681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66683   Dali::LongPressGesture *arg2 = 0 ;
66684
66685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66686   arg2 = (Dali::LongPressGesture *)jarg2;
66687   if (!arg2) {
66688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66689     return ;
66690   }
66691   {
66692     try {
66693       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66694     } catch (std::out_of_range& e) {
66695       {
66696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (std::exception& e) {
66699       {
66700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66701       };
66702     } catch (Dali::DaliException e) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66705       };
66706     } catch (...) {
66707       {
66708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66709       };
66710     }
66711   }
66712
66713 }
66714
66715
66716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66718   Dali::LongPressGesture *arg2 = 0 ;
66719
66720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66721   arg2 = (Dali::LongPressGesture *)jarg2;
66722   if (!arg2) {
66723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66724     return ;
66725   }
66726   {
66727     try {
66728       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66729     } catch (std::out_of_range& e) {
66730       {
66731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66732       };
66733     } catch (std::exception& e) {
66734       {
66735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66736       };
66737     } catch (Dali::DaliException e) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66740       };
66741     } catch (...) {
66742       {
66743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66744       };
66745     }
66746   }
66747
66748 }
66749
66750
66751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66753   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66754   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66755
66756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66757   arg2 = (Dali::SlotObserver *)jarg2;
66758   arg3 = (Dali::CallbackBase *)jarg3;
66759   {
66760     try {
66761       (arg1)->SignalConnected(arg2,arg3);
66762     } catch (std::out_of_range& e) {
66763       {
66764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66765       };
66766     } catch (std::exception& e) {
66767       {
66768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66769       };
66770     } catch (Dali::DaliException e) {
66771       {
66772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66773       };
66774     } catch (...) {
66775       {
66776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66777       };
66778     }
66779   }
66780
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66786   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66787   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66788
66789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66790   arg2 = (Dali::SlotObserver *)jarg2;
66791   arg3 = (Dali::CallbackBase *)jarg3;
66792   {
66793     try {
66794       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66795     } catch (std::out_of_range& e) {
66796       {
66797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (std::exception& e) {
66800       {
66801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66802       };
66803     } catch (Dali::DaliException e) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66806       };
66807     } catch (...) {
66808       {
66809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66810       };
66811     }
66812   }
66813
66814 }
66815
66816
66817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66818   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66819   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66820   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66821
66822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66823   arg2 = (Dali::SlotObserver *)jarg2;
66824   arg3 = (Dali::CallbackBase *)jarg3;
66825   {
66826     try {
66827       (arg1)->SignalDisconnected(arg2,arg3);
66828     } catch (std::out_of_range& e) {
66829       {
66830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66831       };
66832     } catch (std::exception& e) {
66833       {
66834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66835       };
66836     } catch (Dali::DaliException e) {
66837       {
66838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66839       };
66840     } catch (...) {
66841       {
66842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66843       };
66844     }
66845   }
66846
66847 }
66848
66849
66850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66852   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66853   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66854
66855   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66856   arg2 = (Dali::SlotObserver *)jarg2;
66857   arg3 = (Dali::CallbackBase *)jarg3;
66858   {
66859     try {
66860       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66861     } catch (std::out_of_range& e) {
66862       {
66863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66864       };
66865     } catch (std::exception& e) {
66866       {
66867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66868       };
66869     } catch (Dali::DaliException e) {
66870       {
66871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66872       };
66873     } catch (...) {
66874       {
66875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66876       };
66877     }
66878   }
66879
66880 }
66881
66882
66883 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) {
66884   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66885   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66886   if (director) {
66887     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);
66888   }
66889 }
66890
66891
66892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66893   void * jresult ;
66894   Dali::Toolkit::Control *arg1 = 0 ;
66895   Dali::Toolkit::Internal::Control *result = 0 ;
66896
66897   arg1 = (Dali::Toolkit::Control *)jarg1;
66898   if (!arg1) {
66899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66900     return 0;
66901   }
66902   {
66903     try {
66904       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66905     } catch (std::out_of_range& e) {
66906       {
66907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66908       };
66909     } catch (std::exception& e) {
66910       {
66911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66912       };
66913     } catch (Dali::DaliException e) {
66914       {
66915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66916       };
66917     } catch (...) {
66918       {
66919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66920       };
66921     }
66922   }
66923
66924   jresult = (void *)result;
66925   return jresult;
66926 }
66927
66928
66929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66930   int jresult ;
66931   int result;
66932
66933   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66934   jresult = (int)result;
66935   return jresult;
66936 }
66937
66938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66939   int jresult ;
66940   int result;
66941
66942   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66943   jresult = (int)result;
66944   return jresult;
66945 }
66946
66947
66948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66949   int jresult ;
66950   int result;
66951
66952   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66953   jresult = (int)result;
66954   return jresult;
66955 }
66956
66957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66958   int jresult ;
66959   int result;
66960
66961   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66962   jresult = (int)result;
66963   return jresult;
66964 }
66965
66966
66967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66968   int jresult ;
66969   int result;
66970
66971   result = (int)Dali::Toolkit::Control::Property::PADDING;
66972   jresult = (int)result;
66973   return jresult;
66974 }
66975
66976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66977   void * jresult ;
66978   Dali::Toolkit::Control::Property *result = 0 ;
66979
66980   {
66981     try {
66982       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66983     } catch (std::out_of_range& e) {
66984       {
66985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66986       };
66987     } catch (std::exception& e) {
66988       {
66989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66990       };
66991     } catch (Dali::DaliException e) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66994       };
66995     } catch (...) {
66996       {
66997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66998       };
66999     }
67000   }
67001
67002   jresult = (void *)result;
67003   return jresult;
67004 }
67005
67006
67007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67008   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67009
67010   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67011   {
67012     try {
67013       delete arg1;
67014     } catch (std::out_of_range& e) {
67015       {
67016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (std::exception& e) {
67019       {
67020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67021       };
67022     } catch (Dali::DaliException e) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67025       };
67026     } catch (...) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67029       };
67030     }
67031   }
67032
67033 }
67034
67035
67036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67037   void * jresult ;
67038   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67039
67040   {
67041     try {
67042       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67043     } catch (std::out_of_range& e) {
67044       {
67045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67046       };
67047     } catch (std::exception& e) {
67048       {
67049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67050       };
67051     } catch (Dali::DaliException e) {
67052       {
67053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67054       };
67055     } catch (...) {
67056       {
67057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67058       };
67059     }
67060   }
67061
67062   jresult = (void *)result;
67063   return jresult;
67064 }
67065
67066
67067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67068   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67069
67070   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67071   {
67072     try {
67073       delete arg1;
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67081       };
67082     } catch (Dali::DaliException e) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67085       };
67086     } catch (...) {
67087       {
67088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67089       };
67090     }
67091   }
67092
67093 }
67094
67095
67096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67097   void * jresult ;
67098   Dali::Toolkit::Control result;
67099
67100   {
67101     try {
67102       result = Dali::Toolkit::Control::New();
67103     } catch (std::out_of_range& e) {
67104       {
67105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67106       };
67107     } catch (std::exception& e) {
67108       {
67109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67110       };
67111     } catch (Dali::DaliException e) {
67112       {
67113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67114       };
67115     } catch (...) {
67116       {
67117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67118       };
67119     }
67120   }
67121
67122   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67123   return jresult;
67124 }
67125
67126
67127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67128   void * jresult ;
67129   Dali::Toolkit::Control *result = 0 ;
67130
67131   {
67132     try {
67133       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67134     } catch (std::out_of_range& e) {
67135       {
67136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67137       };
67138     } catch (std::exception& e) {
67139       {
67140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67141       };
67142     } catch (Dali::DaliException e) {
67143       {
67144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67145       };
67146     } catch (...) {
67147       {
67148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67149       };
67150     }
67151   }
67152
67153   jresult = (void *)result;
67154   return jresult;
67155 }
67156
67157
67158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67159   void * jresult ;
67160   Dali::Toolkit::Control *arg1 = 0 ;
67161   Dali::Toolkit::Control *result = 0 ;
67162
67163   arg1 = (Dali::Toolkit::Control *)jarg1;
67164   if (!arg1) {
67165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67166     return 0;
67167   }
67168   {
67169     try {
67170       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67171     } catch (std::out_of_range& e) {
67172       {
67173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67174       };
67175     } catch (std::exception& e) {
67176       {
67177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67178       };
67179     } catch (Dali::DaliException e) {
67180       {
67181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67182       };
67183     } catch (...) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67186       };
67187     }
67188   }
67189
67190   jresult = (void *)result;
67191   return jresult;
67192 }
67193
67194
67195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67196   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67197
67198   arg1 = (Dali::Toolkit::Control *)jarg1;
67199   {
67200     try {
67201       delete arg1;
67202     } catch (std::out_of_range& e) {
67203       {
67204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67205       };
67206     } catch (std::exception& e) {
67207       {
67208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67209       };
67210     } catch (Dali::DaliException e) {
67211       {
67212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67213       };
67214     } catch (...) {
67215       {
67216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67217       };
67218     }
67219   }
67220
67221 }
67222
67223
67224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67225   void * jresult ;
67226   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67227   Dali::Toolkit::Control *arg2 = 0 ;
67228   Dali::Toolkit::Control *result = 0 ;
67229
67230   arg1 = (Dali::Toolkit::Control *)jarg1;
67231   arg2 = (Dali::Toolkit::Control *)jarg2;
67232   if (!arg2) {
67233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67234     return 0;
67235   }
67236   {
67237     try {
67238       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67239     } catch (std::out_of_range& e) {
67240       {
67241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67242       };
67243     } catch (std::exception& e) {
67244       {
67245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67246       };
67247     } catch (Dali::DaliException e) {
67248       {
67249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67250       };
67251     } catch (...) {
67252       {
67253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67254       };
67255     }
67256   }
67257
67258   jresult = (void *)result;
67259   return jresult;
67260 }
67261
67262
67263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67264   void * jresult ;
67265   Dali::BaseHandle arg1 ;
67266   Dali::BaseHandle *argp1 ;
67267   Dali::Toolkit::Control result;
67268
67269   argp1 = (Dali::BaseHandle *)jarg1;
67270   if (!argp1) {
67271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67272     return 0;
67273   }
67274   arg1 = *argp1;
67275   {
67276     try {
67277       result = Dali::Toolkit::Control::DownCast(arg1);
67278     } catch (std::out_of_range& e) {
67279       {
67280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (std::exception& e) {
67283       {
67284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67285       };
67286     } catch (Dali::DaliException e) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67289       };
67290     } catch (...) {
67291       {
67292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67293       };
67294     }
67295   }
67296
67297   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67303   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67304
67305   arg1 = (Dali::Toolkit::Control *)jarg1;
67306   {
67307     try {
67308       (arg1)->SetKeyInputFocus();
67309     } catch (std::out_of_range& e) {
67310       {
67311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67312       };
67313     } catch (std::exception& e) {
67314       {
67315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67316       };
67317     } catch (Dali::DaliException e) {
67318       {
67319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67320       };
67321     } catch (...) {
67322       {
67323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67324       };
67325     }
67326   }
67327
67328 }
67329
67330
67331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67332   unsigned int jresult ;
67333   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67334   bool result;
67335
67336   arg1 = (Dali::Toolkit::Control *)jarg1;
67337   {
67338     try {
67339       result = (bool)(arg1)->HasKeyInputFocus();
67340     } catch (std::out_of_range& e) {
67341       {
67342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (std::exception& e) {
67345       {
67346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67347       };
67348     } catch (Dali::DaliException e) {
67349       {
67350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67351       };
67352     } catch (...) {
67353       {
67354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67355       };
67356     }
67357   }
67358
67359   jresult = result;
67360   return jresult;
67361 }
67362
67363
67364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67365   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67366
67367   arg1 = (Dali::Toolkit::Control *)jarg1;
67368   {
67369     try {
67370       (arg1)->ClearKeyInputFocus();
67371     } catch (std::out_of_range& e) {
67372       {
67373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67374       };
67375     } catch (std::exception& e) {
67376       {
67377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67378       };
67379     } catch (Dali::DaliException e) {
67380       {
67381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67382       };
67383     } catch (...) {
67384       {
67385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67386       };
67387     }
67388   }
67389
67390 }
67391
67392
67393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67394   void * jresult ;
67395   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67396   Dali::PinchGestureDetector result;
67397
67398   arg1 = (Dali::Toolkit::Control *)jarg1;
67399   {
67400     try {
67401       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67402     } catch (std::out_of_range& e) {
67403       {
67404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67405       };
67406     } catch (std::exception& e) {
67407       {
67408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67409       };
67410     } catch (Dali::DaliException e) {
67411       {
67412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67413       };
67414     } catch (...) {
67415       {
67416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67417       };
67418     }
67419   }
67420
67421   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67422   return jresult;
67423 }
67424
67425
67426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67427   void * jresult ;
67428   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67429   Dali::PanGestureDetector result;
67430
67431   arg1 = (Dali::Toolkit::Control *)jarg1;
67432   {
67433     try {
67434       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67435     } catch (std::out_of_range& e) {
67436       {
67437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67438       };
67439     } catch (std::exception& e) {
67440       {
67441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67442       };
67443     } catch (Dali::DaliException e) {
67444       {
67445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67446       };
67447     } catch (...) {
67448       {
67449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67450       };
67451     }
67452   }
67453
67454   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67455   return jresult;
67456 }
67457
67458
67459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67460   void * jresult ;
67461   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67462   Dali::TapGestureDetector result;
67463
67464   arg1 = (Dali::Toolkit::Control *)jarg1;
67465   {
67466     try {
67467       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67468     } catch (std::out_of_range& e) {
67469       {
67470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (std::exception& e) {
67473       {
67474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67475       };
67476     } catch (Dali::DaliException e) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67479       };
67480     } catch (...) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67483       };
67484     }
67485   }
67486
67487   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67488   return jresult;
67489 }
67490
67491
67492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67493   void * jresult ;
67494   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67495   Dali::LongPressGestureDetector result;
67496
67497   arg1 = (Dali::Toolkit::Control *)jarg1;
67498   {
67499     try {
67500       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67501     } catch (std::out_of_range& e) {
67502       {
67503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67504       };
67505     } catch (std::exception& e) {
67506       {
67507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67508       };
67509     } catch (Dali::DaliException e) {
67510       {
67511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67512       };
67513     } catch (...) {
67514       {
67515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67516       };
67517     }
67518   }
67519
67520   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67521   return jresult;
67522 }
67523
67524
67525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67526   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67527   std::string *arg2 = 0 ;
67528
67529   arg1 = (Dali::Toolkit::Control *)jarg1;
67530   if (!jarg2) {
67531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67532     return ;
67533   }
67534   std::string arg2_str(jarg2);
67535   arg2 = &arg2_str;
67536   {
67537     try {
67538       (arg1)->SetStyleName((std::string const &)*arg2);
67539     } catch (std::out_of_range& e) {
67540       {
67541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67542       };
67543     } catch (std::exception& e) {
67544       {
67545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67546       };
67547     } catch (Dali::DaliException e) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67550       };
67551     } catch (...) {
67552       {
67553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67554       };
67555     }
67556   }
67557
67558
67559   //argout typemap for const std::string&
67560
67561 }
67562
67563
67564 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67565   char * jresult ;
67566   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67567   std::string *result = 0 ;
67568
67569   arg1 = (Dali::Toolkit::Control *)jarg1;
67570   {
67571     try {
67572       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67573     } catch (std::out_of_range& e) {
67574       {
67575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67576       };
67577     } catch (std::exception& e) {
67578       {
67579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67580       };
67581     } catch (Dali::DaliException e) {
67582       {
67583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67584       };
67585     } catch (...) {
67586       {
67587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67588       };
67589     }
67590   }
67591
67592   jresult = SWIG_csharp_string_callback(result->c_str());
67593   return jresult;
67594 }
67595
67596
67597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67598   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67599   Dali::Vector4 *arg2 = 0 ;
67600
67601   arg1 = (Dali::Toolkit::Control *)jarg1;
67602   arg2 = (Dali::Vector4 *)jarg2;
67603   if (!arg2) {
67604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67605     return ;
67606   }
67607   {
67608     try {
67609       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67610     } catch (std::out_of_range& e) {
67611       {
67612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67613       };
67614     } catch (std::exception& e) {
67615       {
67616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67617       };
67618     } catch (Dali::DaliException e) {
67619       {
67620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67621       };
67622     } catch (...) {
67623       {
67624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67625       };
67626     }
67627   }
67628
67629 }
67630
67631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67632   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67633
67634   arg1 = (Dali::Toolkit::Control *)jarg1;
67635   {
67636     try {
67637       (arg1)->ClearBackground();
67638     } catch (std::out_of_range& e) {
67639       {
67640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67641       };
67642     } catch (std::exception& e) {
67643       {
67644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67645       };
67646     } catch (Dali::DaliException e) {
67647       {
67648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67649       };
67650     } catch (...) {
67651       {
67652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67653       };
67654     }
67655   }
67656
67657 }
67658
67659
67660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67661   void * jresult ;
67662   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67663   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67664
67665   arg1 = (Dali::Toolkit::Control *)jarg1;
67666   {
67667     try {
67668       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67669     } catch (std::out_of_range& e) {
67670       {
67671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67672       };
67673     } catch (std::exception& e) {
67674       {
67675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67676       };
67677     } catch (Dali::DaliException e) {
67678       {
67679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67680       };
67681     } catch (...) {
67682       {
67683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67684       };
67685     }
67686   }
67687
67688   jresult = (void *)result;
67689   return jresult;
67690 }
67691
67692
67693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67694   void * jresult ;
67695   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67696   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67697
67698   arg1 = (Dali::Toolkit::Control *)jarg1;
67699   {
67700     try {
67701       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67702     } catch (std::out_of_range& e) {
67703       {
67704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (std::exception& e) {
67707       {
67708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (Dali::DaliException e) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67713       };
67714     } catch (...) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67717       };
67718     }
67719   }
67720
67721   jresult = (void *)result;
67722   return jresult;
67723 }
67724
67725
67726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67727   void * jresult ;
67728   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67729   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67730
67731   arg1 = (Dali::Toolkit::Control *)jarg1;
67732   {
67733     try {
67734       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67735     } catch (std::out_of_range& e) {
67736       {
67737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67738       };
67739     } catch (std::exception& e) {
67740       {
67741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67742       };
67743     } catch (Dali::DaliException e) {
67744       {
67745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67746       };
67747     } catch (...) {
67748       {
67749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67750       };
67751     }
67752   }
67753
67754   jresult = (void *)result;
67755   return jresult;
67756 }
67757
67758
67759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67760   void * jresult ;
67761   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67762   Dali::Toolkit::Control *result = 0 ;
67763
67764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67765   if (!arg1) {
67766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67767     return 0;
67768   }
67769   {
67770     try {
67771       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67772     } catch (std::out_of_range& e) {
67773       {
67774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (std::exception& e) {
67777       {
67778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67779       };
67780     } catch (Dali::DaliException e) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67783       };
67784     } catch (...) {
67785       {
67786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67787       };
67788     }
67789   }
67790
67791   jresult = (void *)result;
67792   return jresult;
67793 }
67794
67795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67796 {
67797   int jresult;
67798   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67799   arg1 = (Dali::Toolkit::Control *)jarg1;
67800
67801   if (!arg1) {
67802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67803     return 0;
67804   }
67805
67806   Dali::Property::Index arg2 = 0 ;
67807   arg2 = (Dali::Property::Index)jarg2;
67808
67809   Toolkit::Visual::ResourceStatus result;
67810   {
67811     try {
67812       result = arg1->GetVisualResourceStatus(arg2);
67813     } catch (std::out_of_range& e) {
67814       {
67815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67816       };
67817     } catch (std::exception& e) {
67818       {
67819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67824       };
67825     }
67826   }
67827   jresult = (int)(result);
67828   return jresult;
67829 }
67830
67831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67832 {
67833   void * jresult;
67834   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67835   arg1 = (Dali::Toolkit::Control *)jarg1;
67836
67837   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67838
67839   Dali::Toolkit::TransitionData *arg2 = 0 ;
67840   Dali::Animation result;
67841
67842   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67843   if (!arg2) {
67844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67845     return 0;
67846   }
67847   {
67848     try {
67849       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67850     } catch (std::out_of_range& e) {
67851       {
67852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67853       };
67854     } catch (std::exception& e) {
67855       {
67856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67857       };
67858     } catch (Dali::DaliException e) {
67859       {
67860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67861       };
67862     } catch (...) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67865       };
67866     }
67867   }
67868
67869   jresult = new Dali::Animation((const Dali::Animation &)result);
67870   return jresult;
67871 }
67872
67873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67874 {
67875   Dali::Toolkit::Control arg1;
67876   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67877
67878   if (!argp1) {
67879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67880   }
67881   arg1 = *argp1;
67882
67883   Dali::Property::Index arg2 = 0 ;
67884   arg2 = (Dali::Property::Index)jarg2;
67885
67886   Dali::Property::Index arg3 = 0 ;
67887   arg3 = (Dali::Property::Index)jarg3;
67888
67889   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67890
67891   {
67892     try {
67893       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67894     } catch (std::out_of_range& e) {
67895       {
67896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67897       };
67898     } catch (std::exception& e) {
67899       {
67900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67901       };
67902     } catch (...) {
67903       {
67904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67905       };
67906     }
67907   }
67908
67909
67910 }
67911
67912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67913   void * jresult ;
67914   Dali::Toolkit::Control *arg1 = 0 ;
67915   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67916
67917   arg1 = (Dali::Toolkit::Control *)jarg1;
67918   if (!arg1) {
67919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67920     return 0;
67921   }
67922   {
67923     try {
67924       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67925     } catch (std::out_of_range& e) {
67926       {
67927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (std::exception& e) {
67930       {
67931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (Dali::DaliException e) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67936       };
67937     } catch (...) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67940       };
67941     }
67942   }
67943
67944   jresult = (void *)result;
67945   return jresult;
67946 }
67947
67948
67949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
67950   unsigned int jresult ;
67951   Dali::Toolkit::Control *arg1 = 0 ;
67952   bool result;
67953
67954   arg1 = (Dali::Toolkit::Control *)jarg1;
67955   if (!arg1) {
67956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67957     return 0;
67958   }
67959   {
67960     try {
67961       result = (bool)arg1->IsResourceReady();
67962     } catch (std::out_of_range& e) {
67963       {
67964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (std::exception& e) {
67967       {
67968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67969       };
67970     } catch (Dali::DaliException e) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67973       };
67974     } catch (...) {
67975       {
67976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67977       };
67978     }
67979   }
67980
67981   jresult = result;
67982   return jresult;
67983 }
67984
67985
67986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
67987   void * jresult ;
67988   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
67989
67990   {
67991     try {
67992       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
67993     } catch (std::out_of_range& e) {
67994       {
67995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (std::exception& e) {
67998       {
67999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68000       };
68001     } catch (Dali::DaliException e) {
68002       {
68003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68004       };
68005     } catch (...) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68008       };
68009     }
68010   }
68011
68012   jresult = (void *)result;
68013   return jresult;
68014 }
68015
68016
68017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68018   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68019
68020   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68021   {
68022     try {
68023       delete arg1;
68024     } catch (std::out_of_range& e) {
68025       {
68026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68027       };
68028     } catch (std::exception& e) {
68029       {
68030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68031       };
68032     } catch (Dali::DaliException e) {
68033       {
68034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68035       };
68036     } catch (...) {
68037       {
68038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68039       };
68040     }
68041   }
68042
68043 }
68044
68045
68046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68047   void * jresult ;
68048   Dali::Toolkit::KeyInputFocusManager result;
68049
68050   {
68051     try {
68052       result = Dali::Toolkit::KeyInputFocusManager::Get();
68053     } catch (std::out_of_range& e) {
68054       {
68055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68056       };
68057     } catch (std::exception& e) {
68058       {
68059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68060       };
68061     } catch (Dali::DaliException e) {
68062       {
68063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68064       };
68065     } catch (...) {
68066       {
68067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68068       };
68069     }
68070   }
68071
68072   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68073   return jresult;
68074 }
68075
68076
68077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68078   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68079   Dali::Toolkit::Control arg2 ;
68080   Dali::Toolkit::Control *argp2 ;
68081
68082   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68083   argp2 = (Dali::Toolkit::Control *)jarg2;
68084   if (!argp2) {
68085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68086     return ;
68087   }
68088   arg2 = *argp2;
68089   {
68090     try {
68091       (arg1)->SetFocus(arg2);
68092     } catch (std::out_of_range& e) {
68093       {
68094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68095       };
68096     } catch (std::exception& e) {
68097       {
68098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68099       };
68100     } catch (Dali::DaliException e) {
68101       {
68102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68103       };
68104     } catch (...) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68107       };
68108     }
68109   }
68110
68111 }
68112
68113
68114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68115   void * jresult ;
68116   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68117   Dali::Toolkit::Control result;
68118
68119   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68120   {
68121     try {
68122       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68123     } catch (std::out_of_range& e) {
68124       {
68125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68126       };
68127     } catch (std::exception& e) {
68128       {
68129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68130       };
68131     } catch (Dali::DaliException e) {
68132       {
68133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68134       };
68135     } catch (...) {
68136       {
68137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68138       };
68139     }
68140   }
68141
68142   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68143   return jresult;
68144 }
68145
68146
68147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68148   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68149   Dali::Toolkit::Control arg2 ;
68150   Dali::Toolkit::Control *argp2 ;
68151
68152   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68153   argp2 = (Dali::Toolkit::Control *)jarg2;
68154   if (!argp2) {
68155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68156     return ;
68157   }
68158   arg2 = *argp2;
68159   {
68160     try {
68161       (arg1)->RemoveFocus(arg2);
68162     } catch (std::out_of_range& e) {
68163       {
68164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68165       };
68166     } catch (std::exception& e) {
68167       {
68168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68169       };
68170     } catch (Dali::DaliException e) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68173       };
68174     } catch (...) {
68175       {
68176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68177       };
68178     }
68179   }
68180
68181 }
68182
68183
68184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68185   void * jresult ;
68186   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68187   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68188
68189   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68190   {
68191     try {
68192       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68193     } catch (std::out_of_range& e) {
68194       {
68195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68196       };
68197     } catch (std::exception& e) {
68198       {
68199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68200       };
68201     } catch (Dali::DaliException e) {
68202       {
68203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68204       };
68205     } catch (...) {
68206       {
68207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68208       };
68209     }
68210   }
68211
68212   jresult = (void *)result;
68213   return jresult;
68214 }
68215
68216
68217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68218   void * jresult ;
68219   Dali::Toolkit::Alignment::Padding *result = 0 ;
68220
68221   {
68222     try {
68223       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68224     } catch (std::out_of_range& e) {
68225       {
68226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68227       };
68228     } catch (std::exception& e) {
68229       {
68230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68231       };
68232     } catch (Dali::DaliException e) {
68233       {
68234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68235       };
68236     } catch (...) {
68237       {
68238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68239       };
68240     }
68241   }
68242
68243   jresult = (void *)result;
68244   return jresult;
68245 }
68246
68247
68248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68249   void * jresult ;
68250   float arg1 ;
68251   float arg2 ;
68252   float arg3 ;
68253   float arg4 ;
68254   Dali::Toolkit::Alignment::Padding *result = 0 ;
68255
68256   arg1 = (float)jarg1;
68257   arg2 = (float)jarg2;
68258   arg3 = (float)jarg3;
68259   arg4 = (float)jarg4;
68260   {
68261     try {
68262       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68263     } catch (std::out_of_range& e) {
68264       {
68265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68266       };
68267     } catch (std::exception& e) {
68268       {
68269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68270       };
68271     } catch (Dali::DaliException e) {
68272       {
68273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68274       };
68275     } catch (...) {
68276       {
68277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68278       };
68279     }
68280   }
68281
68282   jresult = (void *)result;
68283   return jresult;
68284 }
68285
68286
68287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68288   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68289   float arg2 ;
68290
68291   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68292   arg2 = (float)jarg2;
68293   if (arg1) (arg1)->left = arg2;
68294 }
68295
68296
68297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68298   float jresult ;
68299   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68300   float result;
68301
68302   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68303   result = (float) ((arg1)->left);
68304   jresult = result;
68305   return jresult;
68306 }
68307
68308
68309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68310   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68311   float arg2 ;
68312
68313   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68314   arg2 = (float)jarg2;
68315   if (arg1) (arg1)->right = arg2;
68316 }
68317
68318
68319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68320   float jresult ;
68321   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68322   float result;
68323
68324   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68325   result = (float) ((arg1)->right);
68326   jresult = result;
68327   return jresult;
68328 }
68329
68330
68331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68332   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68333   float arg2 ;
68334
68335   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68336   arg2 = (float)jarg2;
68337   if (arg1) (arg1)->top = arg2;
68338 }
68339
68340
68341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68342   float jresult ;
68343   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68344   float result;
68345
68346   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68347   result = (float) ((arg1)->top);
68348   jresult = result;
68349   return jresult;
68350 }
68351
68352
68353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68354   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68355   float arg2 ;
68356
68357   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68358   arg2 = (float)jarg2;
68359   if (arg1) (arg1)->bottom = arg2;
68360 }
68361
68362
68363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68364   float jresult ;
68365   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68366   float result;
68367
68368   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68369   result = (float) ((arg1)->bottom);
68370   jresult = result;
68371   return jresult;
68372 }
68373
68374
68375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68376   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68377
68378   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68379   {
68380     try {
68381       delete arg1;
68382     } catch (std::out_of_range& e) {
68383       {
68384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68385       };
68386     } catch (std::exception& e) {
68387       {
68388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68389       };
68390     } catch (Dali::DaliException e) {
68391       {
68392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68393       };
68394     } catch (...) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68397       };
68398     }
68399   }
68400
68401 }
68402
68403
68404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68405   void * jresult ;
68406   Dali::Toolkit::Alignment *result = 0 ;
68407
68408   {
68409     try {
68410       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68411     } catch (std::out_of_range& e) {
68412       {
68413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68414       };
68415     } catch (std::exception& e) {
68416       {
68417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68418       };
68419     } catch (Dali::DaliException e) {
68420       {
68421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68422       };
68423     } catch (...) {
68424       {
68425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68426       };
68427     }
68428   }
68429
68430   jresult = (void *)result;
68431   return jresult;
68432 }
68433
68434
68435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68436   void * jresult ;
68437   Dali::Toolkit::Alignment::Type arg1 ;
68438   Dali::Toolkit::Alignment::Type arg2 ;
68439   Dali::Toolkit::Alignment result;
68440
68441   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68442   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68443   {
68444     try {
68445       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68446     } catch (std::out_of_range& e) {
68447       {
68448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68449       };
68450     } catch (std::exception& e) {
68451       {
68452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68453       };
68454     } catch (Dali::DaliException e) {
68455       {
68456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68457       };
68458     } catch (...) {
68459       {
68460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68461       };
68462     }
68463   }
68464
68465   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68466   return jresult;
68467 }
68468
68469
68470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68471   void * jresult ;
68472   Dali::Toolkit::Alignment::Type arg1 ;
68473   Dali::Toolkit::Alignment result;
68474
68475   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68476   {
68477     try {
68478       result = Dali::Toolkit::Alignment::New(arg1);
68479     } catch (std::out_of_range& e) {
68480       {
68481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68482       };
68483     } catch (std::exception& e) {
68484       {
68485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68486       };
68487     } catch (Dali::DaliException e) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68490       };
68491     } catch (...) {
68492       {
68493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68494       };
68495     }
68496   }
68497
68498   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68499   return jresult;
68500 }
68501
68502
68503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68504   void * jresult ;
68505   Dali::Toolkit::Alignment result;
68506
68507   {
68508     try {
68509       result = Dali::Toolkit::Alignment::New();
68510     } catch (std::out_of_range& e) {
68511       {
68512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68513       };
68514     } catch (std::exception& e) {
68515       {
68516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68517       };
68518     } catch (Dali::DaliException e) {
68519       {
68520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68521       };
68522     } catch (...) {
68523       {
68524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68525       };
68526     }
68527   }
68528
68529   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68530   return jresult;
68531 }
68532
68533
68534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68535   void * jresult ;
68536   Dali::Toolkit::Alignment *arg1 = 0 ;
68537   Dali::Toolkit::Alignment *result = 0 ;
68538
68539   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68540   if (!arg1) {
68541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68542     return 0;
68543   }
68544   {
68545     try {
68546       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68547     } catch (std::out_of_range& e) {
68548       {
68549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68550       };
68551     } catch (std::exception& e) {
68552       {
68553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68554       };
68555     } catch (Dali::DaliException e) {
68556       {
68557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68558       };
68559     } catch (...) {
68560       {
68561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68562       };
68563     }
68564   }
68565
68566   jresult = (void *)result;
68567   return jresult;
68568 }
68569
68570
68571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68572   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68573
68574   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68575   {
68576     try {
68577       delete arg1;
68578     } catch (std::out_of_range& e) {
68579       {
68580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68581       };
68582     } catch (std::exception& e) {
68583       {
68584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68585       };
68586     } catch (Dali::DaliException e) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68589       };
68590     } catch (...) {
68591       {
68592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68593       };
68594     }
68595   }
68596
68597 }
68598
68599
68600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68601   void * jresult ;
68602   Dali::BaseHandle arg1 ;
68603   Dali::BaseHandle *argp1 ;
68604   Dali::Toolkit::Alignment result;
68605
68606   argp1 = (Dali::BaseHandle *)jarg1;
68607   if (!argp1) {
68608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68609     return 0;
68610   }
68611   arg1 = *argp1;
68612   {
68613     try {
68614       result = Dali::Toolkit::Alignment::DownCast(arg1);
68615     } catch (std::out_of_range& e) {
68616       {
68617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68618       };
68619     } catch (std::exception& e) {
68620       {
68621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68622       };
68623     } catch (Dali::DaliException e) {
68624       {
68625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68626       };
68627     } catch (...) {
68628       {
68629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68630       };
68631     }
68632   }
68633
68634   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68635   return jresult;
68636 }
68637
68638
68639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68640   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68641   Dali::Toolkit::Alignment::Type arg2 ;
68642
68643   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68644   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68645   {
68646     try {
68647       (arg1)->SetAlignmentType(arg2);
68648     } catch (std::out_of_range& e) {
68649       {
68650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68651       };
68652     } catch (std::exception& e) {
68653       {
68654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68655       };
68656     } catch (Dali::DaliException e) {
68657       {
68658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68659       };
68660     } catch (...) {
68661       {
68662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68663       };
68664     }
68665   }
68666
68667 }
68668
68669
68670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68671   int jresult ;
68672   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68673   Dali::Toolkit::Alignment::Type result;
68674
68675   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68676   {
68677     try {
68678       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68679     } catch (std::out_of_range& e) {
68680       {
68681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (std::exception& e) {
68684       {
68685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (Dali::DaliException e) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68690       };
68691     } catch (...) {
68692       {
68693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68694       };
68695     }
68696   }
68697
68698   jresult = (int)result;
68699   return jresult;
68700 }
68701
68702
68703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68704   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68705   Dali::Toolkit::Alignment::Scaling arg2 ;
68706
68707   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68708   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68709   {
68710     try {
68711       (arg1)->SetScaling(arg2);
68712     } catch (std::out_of_range& e) {
68713       {
68714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68715       };
68716     } catch (std::exception& e) {
68717       {
68718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68719       };
68720     } catch (Dali::DaliException e) {
68721       {
68722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68723       };
68724     } catch (...) {
68725       {
68726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68727       };
68728     }
68729   }
68730
68731 }
68732
68733
68734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68735   int jresult ;
68736   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68737   Dali::Toolkit::Alignment::Scaling result;
68738
68739   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68740   {
68741     try {
68742       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68743     } catch (std::out_of_range& e) {
68744       {
68745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68746       };
68747     } catch (std::exception& e) {
68748       {
68749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68750       };
68751     } catch (Dali::DaliException e) {
68752       {
68753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68754       };
68755     } catch (...) {
68756       {
68757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68758       };
68759     }
68760   }
68761
68762   jresult = (int)result;
68763   return jresult;
68764 }
68765
68766
68767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68768   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68769   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68770
68771   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68772   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68773   if (!arg2) {
68774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68775     return ;
68776   }
68777   {
68778     try {
68779       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68780     } catch (std::out_of_range& e) {
68781       {
68782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68783       };
68784     } catch (std::exception& e) {
68785       {
68786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68787       };
68788     } catch (Dali::DaliException e) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68791       };
68792     } catch (...) {
68793       {
68794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68795       };
68796     }
68797   }
68798
68799 }
68800
68801
68802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68803   void * jresult ;
68804   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68805   Dali::Toolkit::Alignment::Padding *result = 0 ;
68806
68807   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68808   {
68809     try {
68810       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68811     } catch (std::out_of_range& e) {
68812       {
68813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68814       };
68815     } catch (std::exception& e) {
68816       {
68817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68818       };
68819     } catch (Dali::DaliException e) {
68820       {
68821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68822       };
68823     } catch (...) {
68824       {
68825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68826       };
68827     }
68828   }
68829
68830   jresult = (void *)result;
68831   return jresult;
68832 }
68833
68834
68835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68836   void * jresult ;
68837   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68838   Dali::Toolkit::Alignment *arg2 = 0 ;
68839   Dali::Toolkit::Alignment *result = 0 ;
68840
68841   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68842   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68843   if (!arg2) {
68844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68845     return 0;
68846   }
68847   {
68848     try {
68849       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68850     } catch (std::out_of_range& e) {
68851       {
68852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68853       };
68854     } catch (std::exception& e) {
68855       {
68856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68857       };
68858     } catch (Dali::DaliException e) {
68859       {
68860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68861       };
68862     } catch (...) {
68863       {
68864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68865       };
68866     }
68867   }
68868
68869   jresult = (void *)result;
68870   return jresult;
68871 }
68872
68873
68874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68875   int jresult ;
68876   int result;
68877
68878   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68879   jresult = (int)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68885   int jresult ;
68886   int result;
68887
68888   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68889   jresult = (int)result;
68890   return jresult;
68891 }
68892
68893
68894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68895   int jresult ;
68896   int result;
68897
68898   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68899   jresult = (int)result;
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68905   int jresult ;
68906   int result;
68907
68908   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68909   jresult = (int)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68915   int jresult ;
68916   int result;
68917
68918   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68919   jresult = (int)result;
68920   return jresult;
68921 }
68922
68923
68924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68925   int jresult ;
68926   int result;
68927
68928   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68929   jresult = (int)result;
68930   return jresult;
68931 }
68932
68933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
68934   int jresult ;
68935   int result;
68936
68937   result = (int)Dali::Toolkit::Button::Property::LABEL;
68938   jresult = (int)result;
68939   return jresult;
68940 }
68941
68942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
68943   void * jresult ;
68944   Dali::Toolkit::Button::Property *result = 0 ;
68945
68946   {
68947     try {
68948       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
68949     } catch (std::out_of_range& e) {
68950       {
68951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68952       };
68953     } catch (std::exception& e) {
68954       {
68955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68956       };
68957     } catch (Dali::DaliException e) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68960       };
68961     } catch (...) {
68962       {
68963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68964       };
68965     }
68966   }
68967
68968   jresult = (void *)result;
68969   return jresult;
68970 }
68971
68972
68973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
68974   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
68975
68976   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
68977   {
68978     try {
68979       delete arg1;
68980     } catch (std::out_of_range& e) {
68981       {
68982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68983       };
68984     } catch (std::exception& e) {
68985       {
68986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68987       };
68988     } catch (Dali::DaliException e) {
68989       {
68990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68991       };
68992     } catch (...) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68995       };
68996     }
68997   }
68998
68999 }
69000
69001
69002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69003   void * jresult ;
69004   Dali::Toolkit::Button *result = 0 ;
69005
69006   {
69007     try {
69008       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69009     } catch (std::out_of_range& e) {
69010       {
69011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69012       };
69013     } catch (std::exception& e) {
69014       {
69015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69016       };
69017     } catch (Dali::DaliException e) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69020       };
69021     } catch (...) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69024       };
69025     }
69026   }
69027
69028   jresult = (void *)result;
69029   return jresult;
69030 }
69031
69032
69033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69034   void * jresult ;
69035   Dali::Toolkit::Button *arg1 = 0 ;
69036   Dali::Toolkit::Button *result = 0 ;
69037
69038   arg1 = (Dali::Toolkit::Button *)jarg1;
69039   if (!arg1) {
69040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69041     return 0;
69042   }
69043   {
69044     try {
69045       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69046     } catch (std::out_of_range& e) {
69047       {
69048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (std::exception& e) {
69051       {
69052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (Dali::DaliException e) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69057       };
69058     } catch (...) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69061       };
69062     }
69063   }
69064
69065   jresult = (void *)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69071   void * jresult ;
69072   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69073   Dali::Toolkit::Button *arg2 = 0 ;
69074   Dali::Toolkit::Button *result = 0 ;
69075
69076   arg1 = (Dali::Toolkit::Button *)jarg1;
69077   arg2 = (Dali::Toolkit::Button *)jarg2;
69078   if (!arg2) {
69079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69080     return 0;
69081   }
69082   {
69083     try {
69084       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69085     } catch (std::out_of_range& e) {
69086       {
69087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69088       };
69089     } catch (std::exception& e) {
69090       {
69091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69092       };
69093     } catch (Dali::DaliException e) {
69094       {
69095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69096       };
69097     } catch (...) {
69098       {
69099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69100       };
69101     }
69102   }
69103
69104   jresult = (void *)result;
69105   return jresult;
69106 }
69107
69108
69109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69110   void * jresult ;
69111   Dali::BaseHandle arg1 ;
69112   Dali::BaseHandle *argp1 ;
69113   Dali::Toolkit::Button result;
69114
69115   argp1 = (Dali::BaseHandle *)jarg1;
69116   if (!argp1) {
69117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69118     return 0;
69119   }
69120   arg1 = *argp1;
69121   {
69122     try {
69123       result = Dali::Toolkit::Button::DownCast(arg1);
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69131       };
69132     } catch (Dali::DaliException e) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69135       };
69136     } catch (...) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69139       };
69140     }
69141   }
69142
69143   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69144   return jresult;
69145 }
69146
69147
69148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69149   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69150
69151   arg1 = (Dali::Toolkit::Button *)jarg1;
69152   {
69153     try {
69154       delete arg1;
69155     } catch (std::out_of_range& e) {
69156       {
69157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69158       };
69159     } catch (std::exception& e) {
69160       {
69161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69162       };
69163     } catch (Dali::DaliException e) {
69164       {
69165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69166       };
69167     } catch (...) {
69168       {
69169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69170       };
69171     }
69172   }
69173
69174 }
69175
69176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69177   void * jresult ;
69178   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69179   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69180
69181   arg1 = (Dali::Toolkit::Button *)jarg1;
69182   {
69183     try {
69184       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69185     } catch (std::out_of_range& e) {
69186       {
69187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (std::exception& e) {
69190       {
69191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69192       };
69193     } catch (Dali::DaliException e) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69196       };
69197     } catch (...) {
69198       {
69199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69200       };
69201     }
69202   }
69203
69204   jresult = (void *)result;
69205   return jresult;
69206 }
69207
69208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69209   void * jresult ;
69210   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69211   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69212
69213   arg1 = (Dali::Toolkit::Button *)jarg1;
69214   {
69215     try {
69216       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69217     } catch (std::out_of_range& e) {
69218       {
69219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69220       };
69221     } catch (std::exception& e) {
69222       {
69223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69224       };
69225     } catch (Dali::DaliException e) {
69226       {
69227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69228       };
69229     } catch (...) {
69230       {
69231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69232       };
69233     }
69234   }
69235
69236   jresult = (void *)result;
69237   return jresult;
69238 }
69239
69240
69241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69242   void * jresult ;
69243   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69244   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69245
69246   arg1 = (Dali::Toolkit::Button *)jarg1;
69247   {
69248     try {
69249       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69250     } catch (std::out_of_range& e) {
69251       {
69252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69253       };
69254     } catch (std::exception& e) {
69255       {
69256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69257       };
69258     } catch (Dali::DaliException e) {
69259       {
69260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69261       };
69262     } catch (...) {
69263       {
69264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69265       };
69266     }
69267   }
69268
69269   jresult = (void *)result;
69270   return jresult;
69271 }
69272
69273
69274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69275   void * jresult ;
69276   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69277   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69278
69279   arg1 = (Dali::Toolkit::Button *)jarg1;
69280   {
69281     try {
69282       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69283     } catch (std::out_of_range& e) {
69284       {
69285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69286       };
69287     } catch (std::exception& e) {
69288       {
69289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69290       };
69291     } catch (Dali::DaliException e) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69294       };
69295     } catch (...) {
69296       {
69297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69298       };
69299     }
69300   }
69301
69302   jresult = (void *)result;
69303   return jresult;
69304 }
69305
69306
69307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69308   void * jresult ;
69309   Dali::Toolkit::CheckBoxButton *result = 0 ;
69310
69311   {
69312     try {
69313       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69314     } catch (std::out_of_range& e) {
69315       {
69316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69317       };
69318     } catch (std::exception& e) {
69319       {
69320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69321       };
69322     } catch (Dali::DaliException e) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69325       };
69326     } catch (...) {
69327       {
69328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69329       };
69330     }
69331   }
69332
69333   jresult = (void *)result;
69334   return jresult;
69335 }
69336
69337
69338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69339   void * jresult ;
69340   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69341   Dali::Toolkit::CheckBoxButton *result = 0 ;
69342
69343   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69344   if (!arg1) {
69345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69346     return 0;
69347   }
69348   {
69349     try {
69350       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69351     } catch (std::out_of_range& e) {
69352       {
69353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (std::exception& e) {
69356       {
69357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69358       };
69359     } catch (Dali::DaliException e) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69362       };
69363     } catch (...) {
69364       {
69365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69366       };
69367     }
69368   }
69369
69370   jresult = (void *)result;
69371   return jresult;
69372 }
69373
69374
69375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69376   void * jresult ;
69377   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69378   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69379   Dali::Toolkit::CheckBoxButton *result = 0 ;
69380
69381   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69382   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69383   if (!arg2) {
69384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69385     return 0;
69386   }
69387   {
69388     try {
69389       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69390     } catch (std::out_of_range& e) {
69391       {
69392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69393       };
69394     } catch (std::exception& e) {
69395       {
69396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69397       };
69398     } catch (Dali::DaliException e) {
69399       {
69400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69401       };
69402     } catch (...) {
69403       {
69404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69405       };
69406     }
69407   }
69408
69409   jresult = (void *)result;
69410   return jresult;
69411 }
69412
69413
69414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69415   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69416
69417   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69418   {
69419     try {
69420       delete arg1;
69421     } catch (std::out_of_range& e) {
69422       {
69423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69424       };
69425     } catch (std::exception& e) {
69426       {
69427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69428       };
69429     } catch (Dali::DaliException e) {
69430       {
69431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69432       };
69433     } catch (...) {
69434       {
69435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69436       };
69437     }
69438   }
69439
69440 }
69441
69442
69443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69444   void * jresult ;
69445   Dali::Toolkit::CheckBoxButton result;
69446
69447   {
69448     try {
69449       result = Dali::Toolkit::CheckBoxButton::New();
69450     } catch (std::out_of_range& e) {
69451       {
69452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69453       };
69454     } catch (std::exception& e) {
69455       {
69456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69457       };
69458     } catch (Dali::DaliException e) {
69459       {
69460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69461       };
69462     } catch (...) {
69463       {
69464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69465       };
69466     }
69467   }
69468
69469   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69470   return jresult;
69471 }
69472
69473
69474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69475   void * jresult ;
69476   Dali::BaseHandle arg1 ;
69477   Dali::BaseHandle *argp1 ;
69478   Dali::Toolkit::CheckBoxButton result;
69479
69480   argp1 = (Dali::BaseHandle *)jarg1;
69481   if (!argp1) {
69482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69483     return 0;
69484   }
69485   arg1 = *argp1;
69486   {
69487     try {
69488       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69489     } catch (std::out_of_range& e) {
69490       {
69491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (std::exception& e) {
69494       {
69495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (Dali::DaliException e) {
69498       {
69499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69500       };
69501     } catch (...) {
69502       {
69503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69504       };
69505     }
69506   }
69507
69508   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69509   return jresult;
69510 }
69511
69512
69513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69514   int jresult ;
69515   int result;
69516
69517   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69518   jresult = (int)result;
69519   return jresult;
69520 }
69521
69522
69523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69524   int jresult ;
69525   int result;
69526
69527   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69528   jresult = (int)result;
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69534   int jresult ;
69535   int result;
69536
69537   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69538   jresult = (int)result;
69539   return jresult;
69540 }
69541
69542
69543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69544   int jresult ;
69545   int result;
69546
69547   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69548   jresult = (int)result;
69549   return jresult;
69550 }
69551
69552
69553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69554   int jresult ;
69555   int result;
69556
69557   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69558   jresult = (int)result;
69559   return jresult;
69560 }
69561
69562
69563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69564   void * jresult ;
69565   Dali::Toolkit::PushButton::Property *result = 0 ;
69566
69567   {
69568     try {
69569       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69570     } catch (std::out_of_range& e) {
69571       {
69572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (std::exception& e) {
69575       {
69576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69577       };
69578     } catch (Dali::DaliException e) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69581       };
69582     } catch (...) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69585       };
69586     }
69587   }
69588
69589   jresult = (void *)result;
69590   return jresult;
69591 }
69592
69593
69594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69595   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69596
69597   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69598   {
69599     try {
69600       delete arg1;
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69616       };
69617     }
69618   }
69619
69620 }
69621
69622
69623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69624   void * jresult ;
69625   Dali::Toolkit::PushButton *result = 0 ;
69626
69627   {
69628     try {
69629       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69630     } catch (std::out_of_range& e) {
69631       {
69632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69633       };
69634     } catch (std::exception& e) {
69635       {
69636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69637       };
69638     } catch (Dali::DaliException e) {
69639       {
69640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69641       };
69642     } catch (...) {
69643       {
69644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69645       };
69646     }
69647   }
69648
69649   jresult = (void *)result;
69650   return jresult;
69651 }
69652
69653
69654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69655   void * jresult ;
69656   Dali::Toolkit::PushButton *arg1 = 0 ;
69657   Dali::Toolkit::PushButton *result = 0 ;
69658
69659   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69660   if (!arg1) {
69661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69662     return 0;
69663   }
69664   {
69665     try {
69666       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69667     } catch (std::out_of_range& e) {
69668       {
69669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69670       };
69671     } catch (std::exception& e) {
69672       {
69673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (Dali::DaliException e) {
69676       {
69677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69678       };
69679     } catch (...) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69682       };
69683     }
69684   }
69685
69686   jresult = (void *)result;
69687   return jresult;
69688 }
69689
69690
69691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69692   void * jresult ;
69693   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69694   Dali::Toolkit::PushButton *arg2 = 0 ;
69695   Dali::Toolkit::PushButton *result = 0 ;
69696
69697   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69698   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69699   if (!arg2) {
69700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69701     return 0;
69702   }
69703   {
69704     try {
69705       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69706     } catch (std::out_of_range& e) {
69707       {
69708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (std::exception& e) {
69711       {
69712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69713       };
69714     } catch (Dali::DaliException e) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69717       };
69718     } catch (...) {
69719       {
69720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69721       };
69722     }
69723   }
69724
69725   jresult = (void *)result;
69726   return jresult;
69727 }
69728
69729
69730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69731   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69732
69733   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69734   {
69735     try {
69736       delete arg1;
69737     } catch (std::out_of_range& e) {
69738       {
69739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69740       };
69741     } catch (std::exception& e) {
69742       {
69743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69744       };
69745     } catch (Dali::DaliException e) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69748       };
69749     } catch (...) {
69750       {
69751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69752       };
69753     }
69754   }
69755
69756 }
69757
69758
69759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69760   void * jresult ;
69761   Dali::Toolkit::PushButton result;
69762
69763   {
69764     try {
69765       result = Dali::Toolkit::PushButton::New();
69766     } catch (std::out_of_range& e) {
69767       {
69768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (std::exception& e) {
69771       {
69772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69773       };
69774     } catch (Dali::DaliException e) {
69775       {
69776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69777       };
69778     } catch (...) {
69779       {
69780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69781       };
69782     }
69783   }
69784
69785   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69786   return jresult;
69787 }
69788
69789
69790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69791   void * jresult ;
69792   Dali::BaseHandle arg1 ;
69793   Dali::BaseHandle *argp1 ;
69794   Dali::Toolkit::PushButton result;
69795
69796   argp1 = (Dali::BaseHandle *)jarg1;
69797   if (!argp1) {
69798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69799     return 0;
69800   }
69801   arg1 = *argp1;
69802   {
69803     try {
69804       result = Dali::Toolkit::PushButton::DownCast(arg1);
69805     } catch (std::out_of_range& e) {
69806       {
69807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69808       };
69809     } catch (std::exception& e) {
69810       {
69811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69812       };
69813     } catch (Dali::DaliException e) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69816       };
69817     } catch (...) {
69818       {
69819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69820       };
69821     }
69822   }
69823
69824   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69825   return jresult;
69826 }
69827
69828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69829   void * jresult ;
69830   Dali::Toolkit::RadioButton *result = 0 ;
69831
69832   {
69833     try {
69834       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69842       };
69843     } catch (Dali::DaliException e) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69846       };
69847     } catch (...) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69850       };
69851     }
69852   }
69853
69854   jresult = (void *)result;
69855   return jresult;
69856 }
69857
69858
69859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69860   void * jresult ;
69861   Dali::Toolkit::RadioButton *arg1 = 0 ;
69862   Dali::Toolkit::RadioButton *result = 0 ;
69863
69864   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69865   if (!arg1) {
69866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69867     return 0;
69868   }
69869   {
69870     try {
69871       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69872     } catch (std::out_of_range& e) {
69873       {
69874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69875       };
69876     } catch (std::exception& e) {
69877       {
69878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69879       };
69880     } catch (Dali::DaliException e) {
69881       {
69882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69883       };
69884     } catch (...) {
69885       {
69886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69887       };
69888     }
69889   }
69890
69891   jresult = (void *)result;
69892   return jresult;
69893 }
69894
69895
69896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69897   void * jresult ;
69898   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69899   Dali::Toolkit::RadioButton *arg2 = 0 ;
69900   Dali::Toolkit::RadioButton *result = 0 ;
69901
69902   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69903   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69904   if (!arg2) {
69905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69906     return 0;
69907   }
69908   {
69909     try {
69910       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69911     } catch (std::out_of_range& e) {
69912       {
69913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69914       };
69915     } catch (std::exception& e) {
69916       {
69917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69918       };
69919     } catch (Dali::DaliException e) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69922       };
69923     } catch (...) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69926       };
69927     }
69928   }
69929
69930   jresult = (void *)result;
69931   return jresult;
69932 }
69933
69934
69935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
69936   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69937
69938   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69939   {
69940     try {
69941       delete arg1;
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69949       };
69950     } catch (Dali::DaliException e) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69953       };
69954     } catch (...) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69957       };
69958     }
69959   }
69960
69961 }
69962
69963
69964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
69965   void * jresult ;
69966   Dali::Toolkit::RadioButton result;
69967
69968   {
69969     try {
69970       result = Dali::Toolkit::RadioButton::New();
69971     } catch (std::out_of_range& e) {
69972       {
69973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69974       };
69975     } catch (std::exception& e) {
69976       {
69977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (Dali::DaliException e) {
69980       {
69981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69982       };
69983     } catch (...) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69986       };
69987     }
69988   }
69989
69990   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69991   return jresult;
69992 }
69993
69994
69995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
69996   void * jresult ;
69997   std::string *arg1 = 0 ;
69998   Dali::Toolkit::RadioButton result;
69999
70000   if (!jarg1) {
70001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70002     return 0;
70003   }
70004   std::string arg1_str(jarg1);
70005   arg1 = &arg1_str;
70006   {
70007     try {
70008       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (Dali::DaliException e) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027
70028   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70029
70030   //argout typemap for const std::string&
70031
70032   return jresult;
70033 }
70034
70035
70036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70037   void * jresult ;
70038   Dali::BaseHandle arg1 ;
70039   Dali::BaseHandle *argp1 ;
70040   Dali::Toolkit::RadioButton result;
70041
70042   argp1 = (Dali::BaseHandle *)jarg1;
70043   if (!argp1) {
70044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70045     return 0;
70046   }
70047   arg1 = *argp1;
70048   {
70049     try {
70050       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70051     } catch (std::out_of_range& e) {
70052       {
70053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70054       };
70055     } catch (std::exception& e) {
70056       {
70057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70058       };
70059     } catch (Dali::DaliException e) {
70060       {
70061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70062       };
70063     } catch (...) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70066       };
70067     }
70068   }
70069
70070   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70071   return jresult;
70072 }
70073
70074
70075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70076   int jresult ;
70077   int result;
70078
70079   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70080   jresult = (int)result;
70081   return jresult;
70082 }
70083
70084
70085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70086   int jresult ;
70087   int result;
70088
70089   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70090   jresult = (int)result;
70091   return jresult;
70092 }
70093
70094
70095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70096   int jresult ;
70097   int result;
70098
70099   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70100   jresult = (int)result;
70101   return jresult;
70102 }
70103
70104
70105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70106   int jresult ;
70107   int result;
70108
70109   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70110   jresult = (int)result;
70111   return jresult;
70112 }
70113
70114
70115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70116   int jresult ;
70117   int result;
70118
70119   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70120   jresult = (int)result;
70121   return jresult;
70122 }
70123
70124
70125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70126   int jresult ;
70127   int result;
70128
70129   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70130   jresult = (int)result;
70131   return jresult;
70132 }
70133
70134
70135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70136   void * jresult ;
70137   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70138
70139   {
70140     try {
70141       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70142     } catch (std::out_of_range& e) {
70143       {
70144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (std::exception& e) {
70147       {
70148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70149       };
70150     } catch (Dali::DaliException e) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70153       };
70154     } catch (...) {
70155       {
70156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70157       };
70158     }
70159   }
70160
70161   jresult = (void *)result;
70162   return jresult;
70163 }
70164
70165
70166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70167   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70168
70169   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70170   {
70171     try {
70172       delete arg1;
70173     } catch (std::out_of_range& e) {
70174       {
70175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70176       };
70177     } catch (std::exception& e) {
70178       {
70179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70180       };
70181     } catch (Dali::DaliException e) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70184       };
70185     } catch (...) {
70186       {
70187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70188       };
70189     }
70190   }
70191
70192 }
70193
70194
70195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70196   int jresult ;
70197   int result;
70198
70199   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70200   jresult = (int)result;
70201   return jresult;
70202 }
70203
70204
70205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70206   int jresult ;
70207   int result;
70208
70209   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70210   jresult = (int)result;
70211   return jresult;
70212 }
70213
70214
70215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70216   int jresult ;
70217   int result;
70218
70219   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70220   jresult = (int)result;
70221   return jresult;
70222 }
70223
70224
70225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70226   void * jresult ;
70227   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70228
70229   {
70230     try {
70231       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70232     } catch (std::out_of_range& e) {
70233       {
70234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70235       };
70236     } catch (std::exception& e) {
70237       {
70238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70239       };
70240     } catch (Dali::DaliException e) {
70241       {
70242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70243       };
70244     } catch (...) {
70245       {
70246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70247       };
70248     }
70249   }
70250
70251   jresult = (void *)result;
70252   return jresult;
70253 }
70254
70255
70256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70257   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70258
70259   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70260   {
70261     try {
70262       delete arg1;
70263     } catch (std::out_of_range& e) {
70264       {
70265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70266       };
70267     } catch (std::exception& e) {
70268       {
70269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70270       };
70271     } catch (Dali::DaliException e) {
70272       {
70273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70274       };
70275     } catch (...) {
70276       {
70277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70278       };
70279     }
70280   }
70281
70282 }
70283
70284
70285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70286   void * jresult ;
70287   Dali::Toolkit::FlexContainer *result = 0 ;
70288
70289   {
70290     try {
70291       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70292     } catch (std::out_of_range& e) {
70293       {
70294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70295       };
70296     } catch (std::exception& e) {
70297       {
70298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70299       };
70300     } catch (Dali::DaliException e) {
70301       {
70302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70303       };
70304     } catch (...) {
70305       {
70306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70307       };
70308     }
70309   }
70310
70311   jresult = (void *)result;
70312   return jresult;
70313 }
70314
70315
70316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70317   void * jresult ;
70318   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70319   Dali::Toolkit::FlexContainer *result = 0 ;
70320
70321   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70322   if (!arg1) {
70323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70324     return 0;
70325   }
70326   {
70327     try {
70328       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70329     } catch (std::out_of_range& e) {
70330       {
70331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70332       };
70333     } catch (std::exception& e) {
70334       {
70335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70336       };
70337     } catch (Dali::DaliException e) {
70338       {
70339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70340       };
70341     } catch (...) {
70342       {
70343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70344       };
70345     }
70346   }
70347
70348   jresult = (void *)result;
70349   return jresult;
70350 }
70351
70352
70353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70354   void * jresult ;
70355   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70356   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70357   Dali::Toolkit::FlexContainer *result = 0 ;
70358
70359   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70360   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70361   if (!arg2) {
70362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70363     return 0;
70364   }
70365   {
70366     try {
70367       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70368     } catch (std::out_of_range& e) {
70369       {
70370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (std::exception& e) {
70373       {
70374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70375       };
70376     } catch (Dali::DaliException e) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70379       };
70380     } catch (...) {
70381       {
70382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70383       };
70384     }
70385   }
70386
70387   jresult = (void *)result;
70388   return jresult;
70389 }
70390
70391
70392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70393   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70394
70395   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70396   {
70397     try {
70398       delete arg1;
70399     } catch (std::out_of_range& e) {
70400       {
70401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70402       };
70403     } catch (std::exception& e) {
70404       {
70405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70406       };
70407     } catch (Dali::DaliException e) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70410       };
70411     } catch (...) {
70412       {
70413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70414       };
70415     }
70416   }
70417
70418 }
70419
70420
70421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70422   void * jresult ;
70423   Dali::Toolkit::FlexContainer result;
70424
70425   {
70426     try {
70427       result = Dali::Toolkit::FlexContainer::New();
70428     } catch (std::out_of_range& e) {
70429       {
70430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70431       };
70432     } catch (std::exception& e) {
70433       {
70434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70435       };
70436     } catch (Dali::DaliException e) {
70437       {
70438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70439       };
70440     } catch (...) {
70441       {
70442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70443       };
70444     }
70445   }
70446
70447   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70448   return jresult;
70449 }
70450
70451
70452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70453   void * jresult ;
70454   Dali::BaseHandle arg1 ;
70455   Dali::BaseHandle *argp1 ;
70456   Dali::Toolkit::FlexContainer result;
70457
70458   argp1 = (Dali::BaseHandle *)jarg1;
70459   if (!argp1) {
70460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70461     return 0;
70462   }
70463   arg1 = *argp1;
70464   {
70465     try {
70466       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70467     } catch (std::out_of_range& e) {
70468       {
70469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70470       };
70471     } catch (std::exception& e) {
70472       {
70473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70474       };
70475     } catch (Dali::DaliException e) {
70476       {
70477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70478       };
70479     } catch (...) {
70480       {
70481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70482       };
70483     }
70484   }
70485
70486   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70487   return jresult;
70488 }
70489
70490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70491   int jresult ;
70492   int result;
70493
70494   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70495   jresult = (int)result;
70496   return jresult;
70497 }
70498
70499
70500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70501   int jresult ;
70502   int result;
70503
70504   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70505   jresult = (int)result;
70506   return jresult;
70507 }
70508
70509
70510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70511   int jresult ;
70512   int result;
70513
70514   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70515   jresult = (int)result;
70516   return jresult;
70517 }
70518
70519
70520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70521   void * jresult ;
70522   Dali::Toolkit::ImageView::Property *result = 0 ;
70523
70524   {
70525     try {
70526       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70527     } catch (std::out_of_range& e) {
70528       {
70529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70530       };
70531     } catch (std::exception& e) {
70532       {
70533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70534       };
70535     } catch (Dali::DaliException e) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70538       };
70539     } catch (...) {
70540       {
70541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70542       };
70543     }
70544   }
70545
70546   jresult = (void *)result;
70547   return jresult;
70548 }
70549
70550
70551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70552   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70553
70554   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70555   {
70556     try {
70557       delete arg1;
70558     } catch (std::out_of_range& e) {
70559       {
70560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70561       };
70562     } catch (std::exception& e) {
70563       {
70564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70565       };
70566     } catch (Dali::DaliException e) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70569       };
70570     } catch (...) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70573       };
70574     }
70575   }
70576
70577 }
70578
70579
70580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70581   void * jresult ;
70582   Dali::Toolkit::ImageView *result = 0 ;
70583
70584   {
70585     try {
70586       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70587     } catch (std::out_of_range& e) {
70588       {
70589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70590       };
70591     } catch (std::exception& e) {
70592       {
70593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (Dali::DaliException e) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70598       };
70599     } catch (...) {
70600       {
70601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70602       };
70603     }
70604   }
70605
70606   jresult = (void *)result;
70607   return jresult;
70608 }
70609
70610
70611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70612   void * jresult ;
70613   Dali::Toolkit::ImageView result;
70614
70615   {
70616     try {
70617       result = Dali::Toolkit::ImageView::New();
70618     } catch (std::out_of_range& e) {
70619       {
70620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70621       };
70622     } catch (std::exception& e) {
70623       {
70624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70625       };
70626     } catch (Dali::DaliException e) {
70627       {
70628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70629       };
70630     } catch (...) {
70631       {
70632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70633       };
70634     }
70635   }
70636
70637   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70638   return jresult;
70639 }
70640
70641
70642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70643   void * jresult ;
70644   Dali::Image arg1 ;
70645   Dali::Image *argp1 ;
70646   Dali::Toolkit::ImageView result;
70647
70648   argp1 = (Dali::Image *)jarg1;
70649   if (!argp1) {
70650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70651     return 0;
70652   }
70653   arg1 = *argp1;
70654   {
70655     try {
70656       result = Dali::Toolkit::ImageView::New(arg1);
70657     } catch (std::out_of_range& e) {
70658       {
70659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70660       };
70661     } catch (std::exception& e) {
70662       {
70663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70664       };
70665     } catch (Dali::DaliException e) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70668       };
70669     } catch (...) {
70670       {
70671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70672       };
70673     }
70674   }
70675
70676   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70677   return jresult;
70678 }
70679
70680
70681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70682   void * jresult ;
70683   std::string *arg1 = 0 ;
70684   Dali::Toolkit::ImageView result;
70685
70686   if (!jarg1) {
70687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70688     return 0;
70689   }
70690   std::string arg1_str(jarg1);
70691   arg1 = &arg1_str;
70692   {
70693     try {
70694       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70695     } catch (std::out_of_range& e) {
70696       {
70697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70698       };
70699     } catch (std::exception& e) {
70700       {
70701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70702       };
70703     } catch (Dali::DaliException e) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70706       };
70707     } catch (...) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70710       };
70711     }
70712   }
70713
70714   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70715
70716   //argout typemap for const std::string&
70717
70718   return jresult;
70719 }
70720
70721
70722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70723   void * jresult ;
70724   std::string *arg1 = 0 ;
70725   Dali::ImageDimensions arg2 ;
70726   Dali::ImageDimensions *argp2 ;
70727   Dali::Toolkit::ImageView result;
70728
70729   if (!jarg1) {
70730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70731     return 0;
70732   }
70733   std::string arg1_str(jarg1);
70734   arg1 = &arg1_str;
70735   argp2 = (Dali::ImageDimensions *)jarg2;
70736   if (!argp2) {
70737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70738     return 0;
70739   }
70740   arg2 = *argp2;
70741   {
70742     try {
70743       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70744     } catch (std::out_of_range& e) {
70745       {
70746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70747       };
70748     } catch (std::exception& e) {
70749       {
70750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70751       };
70752     } catch (Dali::DaliException e) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70755       };
70756     } catch (...) {
70757       {
70758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70759       };
70760     }
70761   }
70762
70763   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70764
70765   //argout typemap for const std::string&
70766
70767   return jresult;
70768 }
70769
70770
70771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70772   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70773
70774   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70775   {
70776     try {
70777       delete arg1;
70778     } catch (std::out_of_range& e) {
70779       {
70780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70781       };
70782     } catch (std::exception& e) {
70783       {
70784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70785       };
70786     } catch (Dali::DaliException e) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70789       };
70790     } catch (...) {
70791       {
70792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70793       };
70794     }
70795   }
70796
70797 }
70798
70799
70800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70801   void * jresult ;
70802   Dali::Toolkit::ImageView *arg1 = 0 ;
70803   Dali::Toolkit::ImageView *result = 0 ;
70804
70805   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70806   if (!arg1) {
70807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70808     return 0;
70809   }
70810   {
70811     try {
70812       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70813     } catch (std::out_of_range& e) {
70814       {
70815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70816       };
70817     } catch (std::exception& e) {
70818       {
70819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70820       };
70821     } catch (Dali::DaliException e) {
70822       {
70823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70824       };
70825     } catch (...) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70828       };
70829     }
70830   }
70831
70832   jresult = (void *)result;
70833   return jresult;
70834 }
70835
70836
70837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70838   void * jresult ;
70839   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70840   Dali::Toolkit::ImageView *arg2 = 0 ;
70841   Dali::Toolkit::ImageView *result = 0 ;
70842
70843   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70844   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70845   if (!arg2) {
70846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70847     return 0;
70848   }
70849   {
70850     try {
70851       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70852     } catch (std::out_of_range& e) {
70853       {
70854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70855       };
70856     } catch (std::exception& e) {
70857       {
70858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70859       };
70860     } catch (Dali::DaliException e) {
70861       {
70862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70863       };
70864     } catch (...) {
70865       {
70866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70867       };
70868     }
70869   }
70870
70871   jresult = (void *)result;
70872   return jresult;
70873 }
70874
70875
70876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70877   void * jresult ;
70878   Dali::BaseHandle arg1 ;
70879   Dali::BaseHandle *argp1 ;
70880   Dali::Toolkit::ImageView result;
70881
70882   argp1 = (Dali::BaseHandle *)jarg1;
70883   if (!argp1) {
70884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70885     return 0;
70886   }
70887   arg1 = *argp1;
70888   {
70889     try {
70890       result = Dali::Toolkit::ImageView::DownCast(arg1);
70891     } catch (std::out_of_range& e) {
70892       {
70893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70894       };
70895     } catch (std::exception& e) {
70896       {
70897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70898       };
70899     } catch (Dali::DaliException e) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70902       };
70903     } catch (...) {
70904       {
70905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70906       };
70907     }
70908   }
70909
70910   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70911   return jresult;
70912 }
70913
70914
70915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70916   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70917   Dali::Image arg2 ;
70918   Dali::Image *argp2 ;
70919
70920   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70921   argp2 = (Dali::Image *)jarg2;
70922   if (!argp2) {
70923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70924     return ;
70925   }
70926   arg2 = *argp2;
70927   {
70928     try {
70929       (arg1)->SetImage(arg2);
70930     } catch (std::out_of_range& e) {
70931       {
70932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70933       };
70934     } catch (std::exception& e) {
70935       {
70936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70937       };
70938     } catch (Dali::DaliException e) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70941       };
70942     } catch (...) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70945       };
70946     }
70947   }
70948
70949 }
70950
70951
70952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
70953   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70954   std::string *arg2 = 0 ;
70955
70956   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70957   if (!jarg2) {
70958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70959     return ;
70960   }
70961   std::string arg2_str(jarg2);
70962   arg2 = &arg2_str;
70963   {
70964     try {
70965       (arg1)->SetImage((std::string const &)*arg2);
70966     } catch (std::out_of_range& e) {
70967       {
70968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70969       };
70970     } catch (std::exception& e) {
70971       {
70972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70973       };
70974     } catch (Dali::DaliException e) {
70975       {
70976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70977       };
70978     } catch (...) {
70979       {
70980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70981       };
70982     }
70983   }
70984
70985
70986   //argout typemap for const std::string&
70987
70988 }
70989
70990
70991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
70992   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70993   std::string *arg2 = 0 ;
70994   Dali::ImageDimensions arg3 ;
70995   Dali::ImageDimensions *argp3 ;
70996
70997   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70998   if (!jarg2) {
70999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71000     return ;
71001   }
71002   std::string arg2_str(jarg2);
71003   arg2 = &arg2_str;
71004   argp3 = (Dali::ImageDimensions *)jarg3;
71005   if (!argp3) {
71006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71007     return ;
71008   }
71009   arg3 = *argp3;
71010   {
71011     try {
71012       (arg1)->SetImage((std::string const &)*arg2,arg3);
71013     } catch (std::out_of_range& e) {
71014       {
71015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71016       };
71017     } catch (std::exception& e) {
71018       {
71019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71020       };
71021     } catch (Dali::DaliException e) {
71022       {
71023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71028       };
71029     }
71030   }
71031
71032
71033   //argout typemap for const std::string&
71034
71035 }
71036
71037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71038   void * jresult ;
71039   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71040   Dali::Image result;
71041
71042   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71043   {
71044     try {
71045       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71046     } catch (std::out_of_range& e) {
71047       {
71048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71049       };
71050     } catch (std::exception& e) {
71051       {
71052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71053       };
71054     } catch (Dali::DaliException e) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71061       };
71062     }
71063   }
71064
71065   jresult = new Dali::Image((const Dali::Image &)result);
71066   return jresult;
71067 }
71068
71069
71070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71071   int jresult ;
71072   int result;
71073
71074   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71075   jresult = (int)result;
71076   return jresult;
71077 }
71078
71079
71080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71081   int jresult ;
71082   int result;
71083
71084   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71085   jresult = (int)result;
71086   return jresult;
71087 }
71088
71089
71090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71091   int jresult ;
71092   int result;
71093
71094   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71095   jresult = (int)result;
71096   return jresult;
71097 }
71098
71099
71100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71101   int jresult ;
71102   int result;
71103
71104   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71105   jresult = (int)result;
71106   return jresult;
71107 }
71108
71109
71110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71111   int jresult ;
71112   int result;
71113
71114   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71115   jresult = (int)result;
71116   return jresult;
71117 }
71118
71119
71120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71121   int jresult ;
71122   int result;
71123
71124   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71125   jresult = (int)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71131   int jresult ;
71132   int result;
71133
71134   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71135   jresult = (int)result;
71136   return jresult;
71137 }
71138
71139
71140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71141   int jresult ;
71142   int result;
71143
71144   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71145   jresult = (int)result;
71146   return jresult;
71147 }
71148
71149
71150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71151   void * jresult ;
71152   Dali::Toolkit::Model3dView::Property *result = 0 ;
71153
71154   {
71155     try {
71156       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71157     } catch (std::out_of_range& e) {
71158       {
71159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71160       };
71161     } catch (std::exception& e) {
71162       {
71163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71164       };
71165     } catch (Dali::DaliException e) {
71166       {
71167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71168       };
71169     } catch (...) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71172       };
71173     }
71174   }
71175
71176   jresult = (void *)result;
71177   return jresult;
71178 }
71179
71180
71181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71182   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71183
71184   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71185   {
71186     try {
71187       delete arg1;
71188     } catch (std::out_of_range& e) {
71189       {
71190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71191       };
71192     } catch (std::exception& e) {
71193       {
71194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71195       };
71196     } catch (Dali::DaliException e) {
71197       {
71198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71199       };
71200     } catch (...) {
71201       {
71202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71203       };
71204     }
71205   }
71206
71207 }
71208
71209
71210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71211   void * jresult ;
71212   Dali::Toolkit::Model3dView result;
71213
71214   {
71215     try {
71216       result = Dali::Toolkit::Model3dView::New();
71217     } catch (std::out_of_range& e) {
71218       {
71219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71220       };
71221     } catch (std::exception& e) {
71222       {
71223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71224       };
71225     } catch (Dali::DaliException e) {
71226       {
71227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71228       };
71229     } catch (...) {
71230       {
71231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71232       };
71233     }
71234   }
71235
71236   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71237   return jresult;
71238 }
71239
71240
71241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71242   void * jresult ;
71243   std::string *arg1 = 0 ;
71244   std::string *arg2 = 0 ;
71245   std::string *arg3 = 0 ;
71246   Dali::Toolkit::Model3dView result;
71247
71248   if (!jarg1) {
71249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71250     return 0;
71251   }
71252   std::string arg1_str(jarg1);
71253   arg1 = &arg1_str;
71254   if (!jarg2) {
71255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71256     return 0;
71257   }
71258   std::string arg2_str(jarg2);
71259   arg2 = &arg2_str;
71260   if (!jarg3) {
71261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71262     return 0;
71263   }
71264   std::string arg3_str(jarg3);
71265   arg3 = &arg3_str;
71266   {
71267     try {
71268       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71269     } catch (std::out_of_range& e) {
71270       {
71271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71272       };
71273     } catch (std::exception& e) {
71274       {
71275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71276       };
71277     } catch (Dali::DaliException e) {
71278       {
71279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71280       };
71281     } catch (...) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71284       };
71285     }
71286   }
71287
71288   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71289
71290   //argout typemap for const std::string&
71291
71292
71293   //argout typemap for const std::string&
71294
71295
71296   //argout typemap for const std::string&
71297
71298   return jresult;
71299 }
71300
71301
71302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71303   void * jresult ;
71304   Dali::Toolkit::Model3dView *result = 0 ;
71305
71306   {
71307     try {
71308       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71309     } catch (std::out_of_range& e) {
71310       {
71311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71312       };
71313     } catch (std::exception& e) {
71314       {
71315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71316       };
71317     } catch (Dali::DaliException e) {
71318       {
71319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71320       };
71321     } catch (...) {
71322       {
71323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71324       };
71325     }
71326   }
71327
71328   jresult = (void *)result;
71329   return jresult;
71330 }
71331
71332
71333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71334   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71335
71336   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71337   {
71338     try {
71339       delete arg1;
71340     } catch (std::out_of_range& e) {
71341       {
71342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71343       };
71344     } catch (std::exception& e) {
71345       {
71346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71347       };
71348     } catch (Dali::DaliException e) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71351       };
71352     } catch (...) {
71353       {
71354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71355       };
71356     }
71357   }
71358
71359 }
71360
71361
71362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71363   void * jresult ;
71364   Dali::Toolkit::Model3dView *arg1 = 0 ;
71365   Dali::Toolkit::Model3dView *result = 0 ;
71366
71367   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71368   if (!arg1) {
71369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71370     return 0;
71371   }
71372   {
71373     try {
71374       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71375     } catch (std::out_of_range& e) {
71376       {
71377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71378       };
71379     } catch (std::exception& e) {
71380       {
71381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71382       };
71383     } catch (Dali::DaliException e) {
71384       {
71385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71386       };
71387     } catch (...) {
71388       {
71389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71390       };
71391     }
71392   }
71393
71394   jresult = (void *)result;
71395   return jresult;
71396 }
71397
71398
71399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71400   void * jresult ;
71401   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71402   Dali::Toolkit::Model3dView *arg2 = 0 ;
71403   Dali::Toolkit::Model3dView *result = 0 ;
71404
71405   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71406   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71407   if (!arg2) {
71408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71409     return 0;
71410   }
71411   {
71412     try {
71413       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71421       };
71422     } catch (Dali::DaliException e) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71425       };
71426     } catch (...) {
71427       {
71428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71429       };
71430     }
71431   }
71432
71433   jresult = (void *)result;
71434   return jresult;
71435 }
71436
71437
71438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71439   void * jresult ;
71440   Dali::BaseHandle arg1 ;
71441   Dali::BaseHandle *argp1 ;
71442   Dali::Toolkit::Model3dView result;
71443
71444   argp1 = (Dali::BaseHandle *)jarg1;
71445   if (!argp1) {
71446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71447     return 0;
71448   }
71449   arg1 = *argp1;
71450   {
71451     try {
71452       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71453     } catch (std::out_of_range& e) {
71454       {
71455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71456       };
71457     } catch (std::exception& e) {
71458       {
71459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71460       };
71461     } catch (Dali::DaliException e) {
71462       {
71463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71464       };
71465     } catch (...) {
71466       {
71467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71468       };
71469     }
71470   }
71471
71472   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71478   int jresult ;
71479   int result;
71480
71481   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71482   jresult = (int)result;
71483   return jresult;
71484 }
71485
71486
71487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71488   int jresult ;
71489   int result;
71490
71491   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71492   jresult = (int)result;
71493   return jresult;
71494 }
71495
71496
71497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71498   int jresult ;
71499   int result;
71500
71501   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71502   jresult = (int)result;
71503   return jresult;
71504 }
71505
71506
71507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71508   int jresult ;
71509   int result;
71510
71511   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71512   jresult = (int)result;
71513   return jresult;
71514 }
71515
71516
71517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71518   int jresult ;
71519   int result;
71520
71521   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71522   jresult = (int)result;
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71528   int jresult ;
71529   int result;
71530
71531   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71532   jresult = (int)result;
71533   return jresult;
71534 }
71535
71536
71537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71538   int jresult ;
71539   int result;
71540
71541   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71542   jresult = (int)result;
71543   return jresult;
71544 }
71545
71546
71547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71548   int jresult ;
71549   int result;
71550
71551   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71552   jresult = (int)result;
71553   return jresult;
71554 }
71555
71556
71557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71558   int jresult ;
71559   int result;
71560
71561   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71562   jresult = (int)result;
71563   return jresult;
71564 }
71565
71566
71567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71568   void * jresult ;
71569   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71570
71571   {
71572     try {
71573       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71574     } catch (std::out_of_range& e) {
71575       {
71576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71577       };
71578     } catch (std::exception& e) {
71579       {
71580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71581       };
71582     } catch (Dali::DaliException e) {
71583       {
71584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71585       };
71586     } catch (...) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71589       };
71590     }
71591   }
71592
71593   jresult = (void *)result;
71594   return jresult;
71595 }
71596
71597
71598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71599   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71600
71601   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71602   {
71603     try {
71604       delete arg1;
71605     } catch (std::out_of_range& e) {
71606       {
71607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71608       };
71609     } catch (std::exception& e) {
71610       {
71611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (Dali::DaliException e) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71616       };
71617     } catch (...) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71620       };
71621     }
71622   }
71623
71624 }
71625
71626
71627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71628   void * jresult ;
71629   Dali::Toolkit::ScrollBar *result = 0 ;
71630
71631   {
71632     try {
71633       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71634     } catch (std::out_of_range& e) {
71635       {
71636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71637       };
71638     } catch (std::exception& e) {
71639       {
71640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71641       };
71642     } catch (Dali::DaliException e) {
71643       {
71644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71645       };
71646     } catch (...) {
71647       {
71648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71649       };
71650     }
71651   }
71652
71653   jresult = (void *)result;
71654   return jresult;
71655 }
71656
71657
71658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71659   void * jresult ;
71660   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71661   Dali::Toolkit::ScrollBar *result = 0 ;
71662
71663   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71664   if (!arg1) {
71665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71666     return 0;
71667   }
71668   {
71669     try {
71670       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71671     } catch (std::out_of_range& e) {
71672       {
71673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (std::exception& e) {
71676       {
71677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71678       };
71679     } catch (Dali::DaliException e) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71682       };
71683     } catch (...) {
71684       {
71685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71686       };
71687     }
71688   }
71689
71690   jresult = (void *)result;
71691   return jresult;
71692 }
71693
71694
71695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71696   void * jresult ;
71697   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71698   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71699   Dali::Toolkit::ScrollBar *result = 0 ;
71700
71701   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71702   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71703   if (!arg2) {
71704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71705     return 0;
71706   }
71707   {
71708     try {
71709       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71710     } catch (std::out_of_range& e) {
71711       {
71712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71713       };
71714     } catch (std::exception& e) {
71715       {
71716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71717       };
71718     } catch (Dali::DaliException e) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71721       };
71722     } catch (...) {
71723       {
71724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71725       };
71726     }
71727   }
71728
71729   jresult = (void *)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71735   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71736
71737   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71738   {
71739     try {
71740       delete arg1;
71741     } catch (std::out_of_range& e) {
71742       {
71743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71744       };
71745     } catch (std::exception& e) {
71746       {
71747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71748       };
71749     } catch (Dali::DaliException e) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71752       };
71753     } catch (...) {
71754       {
71755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71756       };
71757     }
71758   }
71759
71760 }
71761
71762
71763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71764   void * jresult ;
71765   Dali::Toolkit::ScrollBar::Direction arg1 ;
71766   Dali::Toolkit::ScrollBar result;
71767
71768   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71769   {
71770     try {
71771       result = Dali::Toolkit::ScrollBar::New(arg1);
71772     } catch (std::out_of_range& e) {
71773       {
71774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71775       };
71776     } catch (std::exception& e) {
71777       {
71778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71779       };
71780     } catch (Dali::DaliException e) {
71781       {
71782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71783       };
71784     } catch (...) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71787       };
71788     }
71789   }
71790
71791   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71792   return jresult;
71793 }
71794
71795
71796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71797   void * jresult ;
71798   Dali::Toolkit::ScrollBar result;
71799
71800   {
71801     try {
71802       result = Dali::Toolkit::ScrollBar::New();
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71810       };
71811     } catch (Dali::DaliException e) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71814       };
71815     } catch (...) {
71816       {
71817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71818       };
71819     }
71820   }
71821
71822   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71823   return jresult;
71824 }
71825
71826
71827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71828   void * jresult ;
71829   Dali::BaseHandle arg1 ;
71830   Dali::BaseHandle *argp1 ;
71831   Dali::Toolkit::ScrollBar result;
71832
71833   argp1 = (Dali::BaseHandle *)jarg1;
71834   if (!argp1) {
71835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71836     return 0;
71837   }
71838   arg1 = *argp1;
71839   {
71840     try {
71841       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71842     } catch (std::out_of_range& e) {
71843       {
71844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71845       };
71846     } catch (std::exception& e) {
71847       {
71848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71849       };
71850     } catch (Dali::DaliException e) {
71851       {
71852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71853       };
71854     } catch (...) {
71855       {
71856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71857       };
71858     }
71859   }
71860
71861   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71862   return jresult;
71863 }
71864
71865
71866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71867   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71868   Dali::Handle arg2 ;
71869   Dali::Property::Index arg3 ;
71870   Dali::Property::Index arg4 ;
71871   Dali::Property::Index arg5 ;
71872   Dali::Property::Index arg6 ;
71873   Dali::Handle *argp2 ;
71874
71875   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71876   argp2 = (Dali::Handle *)jarg2;
71877   if (!argp2) {
71878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71879     return ;
71880   }
71881   arg2 = *argp2;
71882   arg3 = (Dali::Property::Index)jarg3;
71883   arg4 = (Dali::Property::Index)jarg4;
71884   arg5 = (Dali::Property::Index)jarg5;
71885   arg6 = (Dali::Property::Index)jarg6;
71886   {
71887     try {
71888       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71889     } catch (std::out_of_range& e) {
71890       {
71891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71892       };
71893     } catch (std::exception& e) {
71894       {
71895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (Dali::DaliException e) {
71898       {
71899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71900       };
71901     } catch (...) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71904       };
71905     }
71906   }
71907
71908 }
71909
71910
71911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71912   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71913   Dali::Actor arg2 ;
71914   Dali::Actor *argp2 ;
71915
71916   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71917   argp2 = (Dali::Actor *)jarg2;
71918   if (!argp2) {
71919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71920     return ;
71921   }
71922   arg2 = *argp2;
71923   {
71924     try {
71925       (arg1)->SetScrollIndicator(arg2);
71926     } catch (std::out_of_range& e) {
71927       {
71928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71929       };
71930     } catch (std::exception& e) {
71931       {
71932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (Dali::DaliException e) {
71935       {
71936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71941       };
71942     }
71943   }
71944
71945 }
71946
71947
71948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
71949   void * jresult ;
71950   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71951   Dali::Actor result;
71952
71953   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71954   {
71955     try {
71956       result = (arg1)->GetScrollIndicator();
71957     } catch (std::out_of_range& e) {
71958       {
71959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71960       };
71961     } catch (std::exception& e) {
71962       {
71963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71964       };
71965     } catch (Dali::DaliException e) {
71966       {
71967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71968       };
71969     } catch (...) {
71970       {
71971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71972       };
71973     }
71974   }
71975
71976   jresult = new Dali::Actor((const Dali::Actor &)result);
71977   return jresult;
71978 }
71979
71980
71981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
71982   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71983   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
71984
71985   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71986   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
71987   if (!arg2) {
71988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
71989     return ;
71990   }
71991   {
71992     try {
71993       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
71994     } catch (std::out_of_range& e) {
71995       {
71996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71997       };
71998     } catch (std::exception& e) {
71999       {
72000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72001       };
72002     } catch (Dali::DaliException e) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72005       };
72006     } catch (...) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72009       };
72010     }
72011   }
72012
72013 }
72014
72015
72016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72017   void * jresult ;
72018   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72019
72020   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72021   {
72022     try {
72023       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()));
72024     } catch (std::out_of_range& e) {
72025       {
72026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72027       };
72028     } catch (std::exception& e) {
72029       {
72030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72031       };
72032     } catch (...) {
72033       {
72034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72035       };
72036     }
72037   }
72038   return jresult;
72039 }
72040
72041
72042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72043   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72044   Dali::Toolkit::ScrollBar::Direction arg2 ;
72045
72046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72047   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72048   {
72049     try {
72050       (arg1)->SetScrollDirection(arg2);
72051     } catch (std::out_of_range& e) {
72052       {
72053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72054       };
72055     } catch (std::exception& e) {
72056       {
72057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72058       };
72059     } catch (Dali::DaliException e) {
72060       {
72061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72062       };
72063     } catch (...) {
72064       {
72065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72066       };
72067     }
72068   }
72069
72070 }
72071
72072
72073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72074   int jresult ;
72075   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72076   Dali::Toolkit::ScrollBar::Direction result;
72077
72078   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72079   {
72080     try {
72081       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72082     } catch (std::out_of_range& e) {
72083       {
72084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72085       };
72086     } catch (std::exception& e) {
72087       {
72088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72089       };
72090     } catch (Dali::DaliException e) {
72091       {
72092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72093       };
72094     } catch (...) {
72095       {
72096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72097       };
72098     }
72099   }
72100
72101   jresult = (int)result;
72102   return jresult;
72103 }
72104
72105
72106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72107   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72108   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72109
72110   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72111   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72112   {
72113     try {
72114       (arg1)->SetIndicatorHeightPolicy(arg2);
72115     } catch (std::out_of_range& e) {
72116       {
72117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72118       };
72119     } catch (std::exception& e) {
72120       {
72121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72122       };
72123     } catch (Dali::DaliException e) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72126       };
72127     } catch (...) {
72128       {
72129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72130       };
72131     }
72132   }
72133
72134 }
72135
72136
72137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72138   int jresult ;
72139   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72140   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72141
72142   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72143   {
72144     try {
72145       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72146     } catch (std::out_of_range& e) {
72147       {
72148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72149       };
72150     } catch (std::exception& e) {
72151       {
72152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72153       };
72154     } catch (Dali::DaliException e) {
72155       {
72156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72157       };
72158     } catch (...) {
72159       {
72160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72161       };
72162     }
72163   }
72164
72165   jresult = (int)result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72171   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72172   float arg2 ;
72173
72174   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72175   arg2 = (float)jarg2;
72176   {
72177     try {
72178       (arg1)->SetIndicatorFixedHeight(arg2);
72179     } catch (std::out_of_range& e) {
72180       {
72181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (std::exception& e) {
72184       {
72185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72186       };
72187     } catch (Dali::DaliException e) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72190       };
72191     } catch (...) {
72192       {
72193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72194       };
72195     }
72196   }
72197
72198 }
72199
72200
72201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72202   float jresult ;
72203   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72204   float result;
72205
72206   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72207   {
72208     try {
72209       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72210     } catch (std::out_of_range& e) {
72211       {
72212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72213       };
72214     } catch (std::exception& e) {
72215       {
72216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72217       };
72218     } catch (Dali::DaliException e) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72221       };
72222     } catch (...) {
72223       {
72224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72225       };
72226     }
72227   }
72228
72229   jresult = result;
72230   return jresult;
72231 }
72232
72233
72234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72235   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72236   float arg2 ;
72237
72238   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72239   arg2 = (float)jarg2;
72240   {
72241     try {
72242       (arg1)->SetIndicatorShowDuration(arg2);
72243     } catch (std::out_of_range& e) {
72244       {
72245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72246       };
72247     } catch (std::exception& e) {
72248       {
72249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72250       };
72251     } catch (Dali::DaliException e) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72254       };
72255     } catch (...) {
72256       {
72257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72258       };
72259     }
72260   }
72261
72262 }
72263
72264
72265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72266   float jresult ;
72267   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72268   float result;
72269
72270   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72271   {
72272     try {
72273       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72274     } catch (std::out_of_range& e) {
72275       {
72276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72277       };
72278     } catch (std::exception& e) {
72279       {
72280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72281       };
72282     } catch (Dali::DaliException e) {
72283       {
72284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72285       };
72286     } catch (...) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72289       };
72290     }
72291   }
72292
72293   jresult = result;
72294   return jresult;
72295 }
72296
72297
72298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72299   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72300   float arg2 ;
72301
72302   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72303   arg2 = (float)jarg2;
72304   {
72305     try {
72306       (arg1)->SetIndicatorHideDuration(arg2);
72307     } catch (std::out_of_range& e) {
72308       {
72309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72310       };
72311     } catch (std::exception& e) {
72312       {
72313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72314       };
72315     } catch (Dali::DaliException e) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72318       };
72319     } catch (...) {
72320       {
72321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72322       };
72323     }
72324   }
72325
72326 }
72327
72328
72329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72330   float jresult ;
72331   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72332   float result;
72333
72334   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72335   {
72336     try {
72337       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72338     } catch (std::out_of_range& e) {
72339       {
72340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (std::exception& e) {
72343       {
72344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72345       };
72346     } catch (Dali::DaliException e) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72349       };
72350     } catch (...) {
72351       {
72352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72353       };
72354     }
72355   }
72356
72357   jresult = result;
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72363   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72364
72365   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72366   {
72367     try {
72368       (arg1)->ShowIndicator();
72369     } catch (std::out_of_range& e) {
72370       {
72371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72372       };
72373     } catch (std::exception& e) {
72374       {
72375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72376       };
72377     } catch (Dali::DaliException e) {
72378       {
72379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72380       };
72381     } catch (...) {
72382       {
72383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72384       };
72385     }
72386   }
72387
72388 }
72389
72390
72391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72392   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72393
72394   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72395   {
72396     try {
72397       (arg1)->HideIndicator();
72398     } catch (std::out_of_range& e) {
72399       {
72400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72401       };
72402     } catch (std::exception& e) {
72403       {
72404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72405       };
72406     } catch (Dali::DaliException e) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72409       };
72410     } catch (...) {
72411       {
72412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72413       };
72414     }
72415   }
72416
72417 }
72418
72419
72420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72421   void * jresult ;
72422   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72423   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72424
72425   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72426   {
72427     try {
72428       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (Dali::DaliException e) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72440       };
72441     } catch (...) {
72442       {
72443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72444       };
72445     }
72446   }
72447
72448   jresult = (void *)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72454   void * jresult ;
72455   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72456   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72457
72458   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72459   {
72460     try {
72461       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72462     } catch (std::out_of_range& e) {
72463       {
72464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72465       };
72466     } catch (std::exception& e) {
72467       {
72468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72469       };
72470     } catch (Dali::DaliException e) {
72471       {
72472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72473       };
72474     } catch (...) {
72475       {
72476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72477       };
72478     }
72479   }
72480
72481   jresult = (void *)result;
72482   return jresult;
72483 }
72484
72485
72486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72487   int jresult ;
72488   int result;
72489
72490   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72491   jresult = (int)result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72497   int jresult ;
72498   int result;
72499
72500   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72501   jresult = (int)result;
72502   return jresult;
72503 }
72504
72505
72506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72507   int jresult ;
72508   int result;
72509
72510   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72511   jresult = (int)result;
72512   return jresult;
72513 }
72514
72515
72516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72517   int jresult ;
72518   int result;
72519
72520   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72521   jresult = (int)result;
72522   return jresult;
72523 }
72524
72525
72526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72527   int jresult ;
72528   int result;
72529
72530   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72531   jresult = (int)result;
72532   return jresult;
72533 }
72534
72535
72536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72537   int jresult ;
72538   int result;
72539
72540   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72541   jresult = (int)result;
72542   return jresult;
72543 }
72544
72545
72546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72547   int jresult ;
72548   int result;
72549
72550   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72551   jresult = (int)result;
72552   return jresult;
72553 }
72554
72555
72556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72557   int jresult ;
72558   int result;
72559
72560   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72561   jresult = (int)result;
72562   return jresult;
72563 }
72564
72565
72566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72567   int jresult ;
72568   int result;
72569
72570   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72571   jresult = (int)result;
72572   return jresult;
72573 }
72574
72575
72576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72577   int jresult ;
72578   int result;
72579
72580   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72581   jresult = (int)result;
72582   return jresult;
72583 }
72584
72585
72586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72587   int jresult ;
72588   int result;
72589
72590   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72591   jresult = (int)result;
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72597   int jresult ;
72598   int result;
72599
72600   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72601   jresult = (int)result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72607   int jresult ;
72608   int result;
72609
72610   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72611   jresult = (int)result;
72612   return jresult;
72613 }
72614
72615
72616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72617   int jresult ;
72618   int result;
72619
72620   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72621   jresult = (int)result;
72622   return jresult;
72623 }
72624
72625
72626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72627   void * jresult ;
72628   Dali::Toolkit::Scrollable::Property *result = 0 ;
72629
72630   {
72631     try {
72632       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72633     } catch (std::out_of_range& e) {
72634       {
72635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72636       };
72637     } catch (std::exception& e) {
72638       {
72639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72640       };
72641     } catch (Dali::DaliException e) {
72642       {
72643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72644       };
72645     } catch (...) {
72646       {
72647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72648       };
72649     }
72650   }
72651
72652   jresult = (void *)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72658   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72659
72660   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72661   {
72662     try {
72663       delete arg1;
72664     } catch (std::out_of_range& e) {
72665       {
72666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72667       };
72668     } catch (std::exception& e) {
72669       {
72670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72671       };
72672     } catch (Dali::DaliException e) {
72673       {
72674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72675       };
72676     } catch (...) {
72677       {
72678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72679       };
72680     }
72681   }
72682
72683 }
72684
72685
72686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72687   void * jresult ;
72688   Dali::Toolkit::Scrollable *result = 0 ;
72689
72690   {
72691     try {
72692       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72693     } catch (std::out_of_range& e) {
72694       {
72695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72696       };
72697     } catch (std::exception& e) {
72698       {
72699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72700       };
72701     } catch (Dali::DaliException e) {
72702       {
72703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72704       };
72705     } catch (...) {
72706       {
72707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72708       };
72709     }
72710   }
72711
72712   jresult = (void *)result;
72713   return jresult;
72714 }
72715
72716
72717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72718   void * jresult ;
72719   Dali::Toolkit::Scrollable *arg1 = 0 ;
72720   Dali::Toolkit::Scrollable *result = 0 ;
72721
72722   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72723   if (!arg1) {
72724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72725     return 0;
72726   }
72727   {
72728     try {
72729       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72730     } catch (std::out_of_range& e) {
72731       {
72732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (std::exception& e) {
72735       {
72736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72737       };
72738     } catch (Dali::DaliException e) {
72739       {
72740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72741       };
72742     } catch (...) {
72743       {
72744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72745       };
72746     }
72747   }
72748
72749   jresult = (void *)result;
72750   return jresult;
72751 }
72752
72753
72754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72755   void * jresult ;
72756   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72757   Dali::Toolkit::Scrollable *arg2 = 0 ;
72758   Dali::Toolkit::Scrollable *result = 0 ;
72759
72760   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72761   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72762   if (!arg2) {
72763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72764     return 0;
72765   }
72766   {
72767     try {
72768       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72769     } catch (std::out_of_range& e) {
72770       {
72771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72772       };
72773     } catch (std::exception& e) {
72774       {
72775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72776       };
72777     } catch (Dali::DaliException e) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72780       };
72781     } catch (...) {
72782       {
72783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72784       };
72785     }
72786   }
72787
72788   jresult = (void *)result;
72789   return jresult;
72790 }
72791
72792
72793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72794   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72795
72796   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72797   {
72798     try {
72799       delete arg1;
72800     } catch (std::out_of_range& e) {
72801       {
72802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72803       };
72804     } catch (std::exception& e) {
72805       {
72806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72807       };
72808     } catch (Dali::DaliException e) {
72809       {
72810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72811       };
72812     } catch (...) {
72813       {
72814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72815       };
72816     }
72817   }
72818
72819 }
72820
72821
72822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72823   void * jresult ;
72824   Dali::BaseHandle arg1 ;
72825   Dali::BaseHandle *argp1 ;
72826   Dali::Toolkit::Scrollable result;
72827
72828   argp1 = (Dali::BaseHandle *)jarg1;
72829   if (!argp1) {
72830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72831     return 0;
72832   }
72833   arg1 = *argp1;
72834   {
72835     try {
72836       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72837     } catch (std::out_of_range& e) {
72838       {
72839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72840       };
72841     } catch (std::exception& e) {
72842       {
72843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72844       };
72845     } catch (Dali::DaliException e) {
72846       {
72847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72848       };
72849     } catch (...) {
72850       {
72851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72852       };
72853     }
72854   }
72855
72856   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72857   return jresult;
72858 }
72859
72860
72861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72862   unsigned int jresult ;
72863   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72864   bool result;
72865
72866   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72867   {
72868     try {
72869       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72870     } catch (std::out_of_range& e) {
72871       {
72872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72873       };
72874     } catch (std::exception& e) {
72875       {
72876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72877       };
72878     } catch (Dali::DaliException e) {
72879       {
72880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72881       };
72882     } catch (...) {
72883       {
72884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72885       };
72886     }
72887   }
72888
72889   jresult = result;
72890   return jresult;
72891 }
72892
72893
72894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72895   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72896   bool arg2 ;
72897
72898   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72899   arg2 = jarg2 ? true : false;
72900   {
72901     try {
72902       (arg1)->SetOvershootEnabled(arg2);
72903     } catch (std::out_of_range& e) {
72904       {
72905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72906       };
72907     } catch (std::exception& e) {
72908       {
72909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72910       };
72911     } catch (Dali::DaliException e) {
72912       {
72913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72914       };
72915     } catch (...) {
72916       {
72917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72918       };
72919     }
72920   }
72921
72922 }
72923
72924
72925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
72926   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72927   Dali::Vector4 *arg2 = 0 ;
72928
72929   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72930   arg2 = (Dali::Vector4 *)jarg2;
72931   if (!arg2) {
72932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
72933     return ;
72934   }
72935   {
72936     try {
72937       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
72938     } catch (std::out_of_range& e) {
72939       {
72940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72941       };
72942     } catch (std::exception& e) {
72943       {
72944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72945       };
72946     } catch (Dali::DaliException e) {
72947       {
72948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72949       };
72950     } catch (...) {
72951       {
72952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72953       };
72954     }
72955   }
72956
72957 }
72958
72959
72960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
72961   void * jresult ;
72962   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72963   Dali::Vector4 result;
72964
72965   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72966   {
72967     try {
72968       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
72969     } catch (std::out_of_range& e) {
72970       {
72971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72972       };
72973     } catch (std::exception& e) {
72974       {
72975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72976       };
72977     } catch (Dali::DaliException e) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72980       };
72981     } catch (...) {
72982       {
72983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72984       };
72985     }
72986   }
72987
72988   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
72989   return jresult;
72990 }
72991
72992
72993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
72994   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72995   float arg2 ;
72996
72997   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72998   arg2 = (float)jarg2;
72999   {
73000     try {
73001       (arg1)->SetOvershootAnimationSpeed(arg2);
73002     } catch (std::out_of_range& e) {
73003       {
73004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73005       };
73006     } catch (std::exception& e) {
73007       {
73008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73009       };
73010     } catch (Dali::DaliException e) {
73011       {
73012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73013       };
73014     } catch (...) {
73015       {
73016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73017       };
73018     }
73019   }
73020
73021 }
73022
73023
73024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73025   float jresult ;
73026   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73027   float result;
73028
73029   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73030   {
73031     try {
73032       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73033     } catch (std::out_of_range& e) {
73034       {
73035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (std::exception& e) {
73038       {
73039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (Dali::DaliException e) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73044       };
73045     } catch (...) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73048       };
73049     }
73050   }
73051
73052   jresult = result;
73053   return jresult;
73054 }
73055
73056
73057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73058   void * jresult ;
73059   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73060   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73061
73062   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73063   {
73064     try {
73065       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (Dali::DaliException e) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73081       };
73082     }
73083   }
73084
73085   jresult = (void *)result;
73086   return jresult;
73087 }
73088
73089
73090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73091   void * jresult ;
73092   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73093   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73094
73095   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73096   {
73097     try {
73098       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73099     } catch (std::out_of_range& e) {
73100       {
73101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (std::exception& e) {
73104       {
73105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73106       };
73107     } catch (Dali::DaliException e) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73110       };
73111     } catch (...) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73114       };
73115     }
73116   }
73117
73118   jresult = (void *)result;
73119   return jresult;
73120 }
73121
73122
73123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73124   void * jresult ;
73125   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73126   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73127
73128   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73129   {
73130     try {
73131       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73132     } catch (std::out_of_range& e) {
73133       {
73134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73135       };
73136     } catch (std::exception& e) {
73137       {
73138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73139       };
73140     } catch (Dali::DaliException e) {
73141       {
73142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73143       };
73144     } catch (...) {
73145       {
73146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73147       };
73148     }
73149   }
73150
73151   jresult = (void *)result;
73152   return jresult;
73153 }
73154
73155
73156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73157   unsigned int jresult ;
73158   Dali::Toolkit::ControlOrientation::Type arg1 ;
73159   bool result;
73160
73161   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73162   {
73163     try {
73164       result = (bool)Dali::Toolkit::IsVertical(arg1);
73165     } catch (std::out_of_range& e) {
73166       {
73167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73168       };
73169     } catch (std::exception& e) {
73170       {
73171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73172       };
73173     } catch (Dali::DaliException e) {
73174       {
73175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73176       };
73177     } catch (...) {
73178       {
73179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73180       };
73181     }
73182   }
73183
73184   jresult = result;
73185   return jresult;
73186 }
73187
73188
73189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73190   unsigned int jresult ;
73191   Dali::Toolkit::ControlOrientation::Type arg1 ;
73192   bool result;
73193
73194   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73195   {
73196     try {
73197       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73198     } catch (std::out_of_range& e) {
73199       {
73200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (std::exception& e) {
73203       {
73204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73205       };
73206     } catch (Dali::DaliException e) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73209       };
73210     } catch (...) {
73211       {
73212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73213       };
73214     }
73215   }
73216
73217   jresult = result;
73218   return jresult;
73219 }
73220
73221
73222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73223   void * jresult ;
73224   unsigned int arg1 ;
73225   unsigned int arg2 ;
73226   Dali::Toolkit::ItemRange *result = 0 ;
73227
73228   arg1 = (unsigned int)jarg1;
73229   arg2 = (unsigned int)jarg2;
73230   {
73231     try {
73232       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73233     } catch (std::out_of_range& e) {
73234       {
73235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73236       };
73237     } catch (std::exception& e) {
73238       {
73239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73240       };
73241     } catch (Dali::DaliException e) {
73242       {
73243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73244       };
73245     } catch (...) {
73246       {
73247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73248       };
73249     }
73250   }
73251
73252   jresult = (void *)result;
73253   return jresult;
73254 }
73255
73256
73257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73258   void * jresult ;
73259   Dali::Toolkit::ItemRange *arg1 = 0 ;
73260   Dali::Toolkit::ItemRange *result = 0 ;
73261
73262   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73263   if (!arg1) {
73264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73265     return 0;
73266   }
73267   {
73268     try {
73269       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73270     } catch (std::out_of_range& e) {
73271       {
73272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73273       };
73274     } catch (std::exception& e) {
73275       {
73276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73277       };
73278     } catch (Dali::DaliException e) {
73279       {
73280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73281       };
73282     } catch (...) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73285       };
73286     }
73287   }
73288
73289   jresult = (void *)result;
73290   return jresult;
73291 }
73292
73293
73294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73295   void * jresult ;
73296   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73297   Dali::Toolkit::ItemRange *arg2 = 0 ;
73298   Dali::Toolkit::ItemRange *result = 0 ;
73299
73300   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73301   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73302   if (!arg2) {
73303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73304     return 0;
73305   }
73306   {
73307     try {
73308       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73309     } catch (std::out_of_range& e) {
73310       {
73311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73312       };
73313     } catch (std::exception& e) {
73314       {
73315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73316       };
73317     } catch (Dali::DaliException e) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73320       };
73321     } catch (...) {
73322       {
73323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73324       };
73325     }
73326   }
73327
73328   jresult = (void *)result;
73329   return jresult;
73330 }
73331
73332
73333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73334   unsigned int jresult ;
73335   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73336   unsigned int arg2 ;
73337   bool result;
73338
73339   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73340   arg2 = (unsigned int)jarg2;
73341   {
73342     try {
73343       result = (bool)(arg1)->Within(arg2);
73344     } catch (std::out_of_range& e) {
73345       {
73346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73347       };
73348     } catch (std::exception& e) {
73349       {
73350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73351       };
73352     } catch (Dali::DaliException e) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73355       };
73356     } catch (...) {
73357       {
73358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73359       };
73360     }
73361   }
73362
73363   jresult = result;
73364   return jresult;
73365 }
73366
73367
73368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73369   void * jresult ;
73370   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73371   Dali::Toolkit::ItemRange *arg2 = 0 ;
73372   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73373
73374   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73375   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73376   if (!arg2) {
73377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73378     return 0;
73379   }
73380   {
73381     try {
73382       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73383     } catch (std::out_of_range& e) {
73384       {
73385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (std::exception& e) {
73388       {
73389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73390       };
73391     } catch (Dali::DaliException e) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73394       };
73395     } catch (...) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73398       };
73399     }
73400   }
73401
73402   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73403   return jresult;
73404 }
73405
73406
73407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73408   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73409   unsigned int arg2 ;
73410
73411   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73412   arg2 = (unsigned int)jarg2;
73413   if (arg1) (arg1)->begin = arg2;
73414 }
73415
73416
73417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73418   unsigned int jresult ;
73419   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73420   unsigned int result;
73421
73422   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73423   result = (unsigned int) ((arg1)->begin);
73424   jresult = result;
73425   return jresult;
73426 }
73427
73428
73429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73430   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73431   unsigned int arg2 ;
73432
73433   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73434   arg2 = (unsigned int)jarg2;
73435   if (arg1) (arg1)->end = arg2;
73436 }
73437
73438
73439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73440   unsigned int jresult ;
73441   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73442   unsigned int result;
73443
73444   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73445   result = (unsigned int) ((arg1)->end);
73446   jresult = result;
73447   return jresult;
73448 }
73449
73450
73451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73452   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73453
73454   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73455   {
73456     try {
73457       delete arg1;
73458     } catch (std::out_of_range& e) {
73459       {
73460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73461       };
73462     } catch (std::exception& e) {
73463       {
73464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73465       };
73466     } catch (Dali::DaliException e) {
73467       {
73468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73469       };
73470     } catch (...) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73473       };
73474     }
73475   }
73476
73477 }
73478
73479
73480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73481   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73482
73483   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73484   {
73485     try {
73486       delete arg1;
73487     } catch (std::out_of_range& e) {
73488       {
73489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73490       };
73491     } catch (std::exception& e) {
73492       {
73493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73494       };
73495     } catch (Dali::DaliException e) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73498       };
73499     } catch (...) {
73500       {
73501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73502       };
73503     }
73504   }
73505
73506 }
73507
73508
73509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73510   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73511   Dali::Toolkit::ControlOrientation::Type arg2 ;
73512
73513   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73514   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73515   {
73516     try {
73517       (arg1)->SetOrientation(arg2);
73518     } catch (std::out_of_range& e) {
73519       {
73520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73521       };
73522     } catch (std::exception& e) {
73523       {
73524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73525       };
73526     } catch (Dali::DaliException e) {
73527       {
73528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73529       };
73530     } catch (...) {
73531       {
73532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73533       };
73534     }
73535   }
73536
73537 }
73538
73539
73540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73541   int jresult ;
73542   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73543   Dali::Toolkit::ControlOrientation::Type result;
73544
73545   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73546   {
73547     try {
73548       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73549     } catch (std::out_of_range& e) {
73550       {
73551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73552       };
73553     } catch (std::exception& e) {
73554       {
73555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73556       };
73557     } catch (Dali::DaliException e) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73560       };
73561     } catch (...) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73564       };
73565     }
73566   }
73567
73568   jresult = (int)result;
73569   return jresult;
73570 }
73571
73572
73573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73574   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73575   Dali::Property::Map *arg2 = 0 ;
73576
73577   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73578   arg2 = (Dali::Property::Map *)jarg2;
73579   if (!arg2) {
73580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73581     return ;
73582   }
73583   {
73584     try {
73585       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73586     } catch (std::out_of_range& e) {
73587       {
73588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73589       };
73590     } catch (std::exception& e) {
73591       {
73592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73593       };
73594     } catch (Dali::DaliException e) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73597       };
73598     } catch (...) {
73599       {
73600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73601       };
73602     }
73603   }
73604
73605 }
73606
73607
73608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73609   void * jresult ;
73610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73611   Dali::Property::Map result;
73612
73613   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73614   {
73615     try {
73616       result = (arg1)->GetLayoutProperties();
73617     } catch (std::out_of_range& e) {
73618       {
73619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73620       };
73621     } catch (std::exception& e) {
73622       {
73623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73624       };
73625     } catch (Dali::DaliException e) {
73626       {
73627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73628       };
73629     } catch (...) {
73630       {
73631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73632       };
73633     }
73634   }
73635
73636   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73637   return jresult;
73638 }
73639
73640
73641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73642   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73643   unsigned int arg2 ;
73644   Dali::Vector3 *arg3 = 0 ;
73645   Dali::Vector3 *arg4 = 0 ;
73646
73647   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73648   arg2 = (unsigned int)jarg2;
73649   arg3 = (Dali::Vector3 *)jarg3;
73650   if (!arg3) {
73651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73652     return ;
73653   }
73654   arg4 = (Dali::Vector3 *)jarg4;
73655   if (!arg4) {
73656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73657     return ;
73658   }
73659   {
73660     try {
73661       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73662     } catch (std::out_of_range& e) {
73663       {
73664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73665       };
73666     } catch (std::exception& e) {
73667       {
73668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73669       };
73670     } catch (Dali::DaliException e) {
73671       {
73672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73673       };
73674     } catch (...) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73677       };
73678     }
73679   }
73680
73681 }
73682
73683
73684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73685   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73686   Dali::Vector3 *arg2 = 0 ;
73687
73688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73689   arg2 = (Dali::Vector3 *)jarg2;
73690   if (!arg2) {
73691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73692     return ;
73693   }
73694   {
73695     try {
73696       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73697     } catch (std::out_of_range& e) {
73698       {
73699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73700       };
73701     } catch (std::exception& e) {
73702       {
73703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73704       };
73705     } catch (Dali::DaliException e) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73708       };
73709     } catch (...) {
73710       {
73711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73712       };
73713     }
73714   }
73715
73716 }
73717
73718
73719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73720   float jresult ;
73721   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73722   unsigned int arg2 ;
73723   Dali::Vector3 arg3 ;
73724   Dali::Vector3 *argp3 ;
73725   float result;
73726
73727   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73728   arg2 = (unsigned int)jarg2;
73729   argp3 = (Dali::Vector3 *)jarg3;
73730   if (!argp3) {
73731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73732     return 0;
73733   }
73734   arg3 = *argp3;
73735   {
73736     try {
73737       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73738     } catch (std::out_of_range& e) {
73739       {
73740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73741       };
73742     } catch (std::exception& e) {
73743       {
73744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73745       };
73746     } catch (Dali::DaliException e) {
73747       {
73748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73749       };
73750     } catch (...) {
73751       {
73752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73753       };
73754     }
73755   }
73756
73757   jresult = result;
73758   return jresult;
73759 }
73760
73761
73762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73763   float jresult ;
73764   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73765   float arg2 ;
73766   float result;
73767
73768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73769   arg2 = (float)jarg2;
73770   {
73771     try {
73772       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73773     } catch (std::out_of_range& e) {
73774       {
73775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (std::exception& e) {
73778       {
73779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73780       };
73781     } catch (Dali::DaliException e) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73784       };
73785     } catch (...) {
73786       {
73787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73788       };
73789     }
73790   }
73791
73792   jresult = result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73798   float jresult ;
73799   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73800   unsigned int arg2 ;
73801   float result;
73802
73803   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73804   arg2 = (unsigned int)jarg2;
73805   {
73806     try {
73807       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73808     } catch (std::out_of_range& e) {
73809       {
73810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73811       };
73812     } catch (std::exception& e) {
73813       {
73814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73815       };
73816     } catch (Dali::DaliException e) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73819       };
73820     } catch (...) {
73821       {
73822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73823       };
73824     }
73825   }
73826
73827   jresult = result;
73828   return jresult;
73829 }
73830
73831
73832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73833   void * jresult ;
73834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73835   float arg2 ;
73836   Dali::Vector3 arg3 ;
73837   Dali::Vector3 *argp3 ;
73838   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73839
73840   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73841   arg2 = (float)jarg2;
73842   argp3 = (Dali::Vector3 *)jarg3;
73843   if (!argp3) {
73844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73845     return 0;
73846   }
73847   arg3 = *argp3;
73848   {
73849     try {
73850       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73851     } catch (std::out_of_range& e) {
73852       {
73853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73854       };
73855     } catch (std::exception& e) {
73856       {
73857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (Dali::DaliException e) {
73860       {
73861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73862       };
73863     } catch (...) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73866       };
73867     }
73868   }
73869
73870   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73871   return jresult;
73872 }
73873
73874
73875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73876   float jresult ;
73877   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73878   int arg2 ;
73879   float arg3 ;
73880   Dali::Vector3 *arg4 = 0 ;
73881   float result;
73882
73883   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73884   arg2 = (int)jarg2;
73885   arg3 = (float)jarg3;
73886   arg4 = (Dali::Vector3 *)jarg4;
73887   if (!arg4) {
73888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73889     return 0;
73890   }
73891   {
73892     try {
73893       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73894     } catch (std::out_of_range& e) {
73895       {
73896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73897       };
73898     } catch (std::exception& e) {
73899       {
73900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73901       };
73902     } catch (Dali::DaliException e) {
73903       {
73904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73905       };
73906     } catch (...) {
73907       {
73908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73909       };
73910     }
73911   }
73912
73913   jresult = result;
73914   return jresult;
73915 }
73916
73917
73918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73919   unsigned int jresult ;
73920   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73921   Dali::Vector3 arg2 ;
73922   Dali::Vector3 *argp2 ;
73923   unsigned int result;
73924
73925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73926   argp2 = (Dali::Vector3 *)jarg2;
73927   if (!argp2) {
73928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73929     return 0;
73930   }
73931   arg2 = *argp2;
73932   {
73933     try {
73934       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
73935     } catch (std::out_of_range& e) {
73936       {
73937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73938       };
73939     } catch (std::exception& e) {
73940       {
73941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73942       };
73943     } catch (Dali::DaliException e) {
73944       {
73945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73946       };
73947     } catch (...) {
73948       {
73949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73950       };
73951     }
73952   }
73953
73954   jresult = result;
73955   return jresult;
73956 }
73957
73958
73959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73960   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73961   unsigned int arg2 ;
73962   Dali::Vector3 *arg3 = 0 ;
73963   Dali::Vector3 *arg4 = 0 ;
73964
73965   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73966   arg2 = (unsigned int)jarg2;
73967   arg3 = (Dali::Vector3 *)jarg3;
73968   if (!arg3) {
73969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73970     return ;
73971   }
73972   arg4 = (Dali::Vector3 *)jarg4;
73973   if (!arg4) {
73974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73975     return ;
73976   }
73977   {
73978     try {
73979       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73980     } catch (std::out_of_range& e) {
73981       {
73982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (std::exception& e) {
73985       {
73986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73987       };
73988     } catch (Dali::DaliException e) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73991       };
73992     } catch (...) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73995       };
73996     }
73997   }
73998
73999 }
74000
74001
74002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74003   void * jresult ;
74004   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74005   Dali::Degree result;
74006
74007   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74008   {
74009     try {
74010       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (Dali::DaliException e) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74022       };
74023     } catch (...) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74026       };
74027     }
74028   }
74029
74030   jresult = new Dali::Degree((const Dali::Degree &)result);
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74036   float jresult ;
74037   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74038   float result;
74039
74040   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74041   {
74042     try {
74043       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74044     } catch (std::out_of_range& e) {
74045       {
74046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (std::exception& e) {
74049       {
74050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74051       };
74052     } catch (Dali::DaliException e) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74055       };
74056     } catch (...) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74059       };
74060     }
74061   }
74062
74063   jresult = result;
74064   return jresult;
74065 }
74066
74067
74068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74069   float jresult ;
74070   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74071   float result;
74072
74073   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74074   {
74075     try {
74076       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74077     } catch (std::out_of_range& e) {
74078       {
74079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74080       };
74081     } catch (std::exception& e) {
74082       {
74083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74084       };
74085     } catch (Dali::DaliException e) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74088       };
74089     } catch (...) {
74090       {
74091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74092       };
74093     }
74094   }
74095
74096   jresult = result;
74097   return jresult;
74098 }
74099
74100
74101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74102   float jresult ;
74103   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74104   float result;
74105
74106   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74107   {
74108     try {
74109       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74110     } catch (std::out_of_range& e) {
74111       {
74112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (std::exception& e) {
74115       {
74116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74117       };
74118     } catch (Dali::DaliException e) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74121       };
74122     } catch (...) {
74123       {
74124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74125       };
74126     }
74127   }
74128
74129   jresult = result;
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74135   int jresult ;
74136   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74137   int arg2 ;
74138   int arg3 ;
74139   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74140   bool arg5 ;
74141   int result;
74142
74143   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74144   arg2 = (int)jarg2;
74145   arg3 = (int)jarg3;
74146   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74147   arg5 = jarg5 ? true : false;
74148   {
74149     try {
74150       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74151     } catch (std::out_of_range& e) {
74152       {
74153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (std::exception& e) {
74156       {
74157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74158       };
74159     } catch (Dali::DaliException e) {
74160       {
74161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74162       };
74163     } catch (...) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74166       };
74167     }
74168   }
74169
74170   jresult = result;
74171   return jresult;
74172 }
74173
74174
74175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74176   float jresult ;
74177   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74178   float result;
74179
74180   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74181   {
74182     try {
74183       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74184     } catch (std::out_of_range& e) {
74185       {
74186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74187       };
74188     } catch (std::exception& e) {
74189       {
74190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74191       };
74192     } catch (Dali::DaliException e) {
74193       {
74194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74195       };
74196     } catch (...) {
74197       {
74198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74199       };
74200     }
74201   }
74202
74203   jresult = result;
74204   return jresult;
74205 }
74206
74207
74208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74209   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74210   Dali::Actor *arg2 = 0 ;
74211   int arg3 ;
74212   Dali::Vector3 *arg4 = 0 ;
74213   Dali::Actor *arg5 = 0 ;
74214
74215   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74216   arg2 = (Dali::Actor *)jarg2;
74217   if (!arg2) {
74218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74219     return ;
74220   }
74221   arg3 = (int)jarg3;
74222   arg4 = (Dali::Vector3 *)jarg4;
74223   if (!arg4) {
74224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74225     return ;
74226   }
74227   arg5 = (Dali::Actor *)jarg5;
74228   if (!arg5) {
74229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74230     return ;
74231   }
74232   {
74233     try {
74234       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74235     } catch (std::out_of_range& e) {
74236       {
74237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74238       };
74239     } catch (std::exception& e) {
74240       {
74241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74242       };
74243     } catch (Dali::DaliException e) {
74244       {
74245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74246       };
74247     } catch (...) {
74248       {
74249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74250       };
74251     }
74252   }
74253
74254 }
74255
74256
74257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74258   void * jresult ;
74259   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74260   int arg2 ;
74261   float arg3 ;
74262   Dali::Vector3 *arg4 = 0 ;
74263   Dali::Vector3 result;
74264
74265   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74266   arg2 = (int)jarg2;
74267   arg3 = (float)jarg3;
74268   arg4 = (Dali::Vector3 *)jarg4;
74269   if (!arg4) {
74270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74271     return 0;
74272   }
74273   {
74274     try {
74275       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74276     } catch (std::out_of_range& e) {
74277       {
74278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74279       };
74280     } catch (std::exception& e) {
74281       {
74282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (Dali::DaliException e) {
74285       {
74286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74287       };
74288     } catch (...) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74291       };
74292     }
74293   }
74294
74295   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74296   return jresult;
74297 }
74298
74299
74300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74301   void * jresult ;
74302   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74303   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74304
74305   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74306   {
74307     try {
74308       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74309     } catch (std::out_of_range& e) {
74310       {
74311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74312       };
74313     } catch (std::exception& e) {
74314       {
74315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74316       };
74317     } catch (Dali::DaliException e) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74320       };
74321     } catch (...) {
74322       {
74323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74324       };
74325     }
74326   }
74327
74328   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74329   return jresult;
74330 }
74331
74332
74333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74334   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74335
74336   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74337   {
74338     try {
74339       delete arg1;
74340     } catch (std::out_of_range& e) {
74341       {
74342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74343       };
74344     } catch (std::exception& e) {
74345       {
74346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74347       };
74348     } catch (Dali::DaliException e) {
74349       {
74350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74351       };
74352     } catch (...) {
74353       {
74354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74355       };
74356     }
74357   }
74358
74359 }
74360
74361
74362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74363   unsigned int jresult ;
74364   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74365   unsigned int result;
74366
74367   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74368   {
74369     try {
74370       result = (unsigned int)(arg1)->GetNumberOfItems();
74371     } catch (std::out_of_range& e) {
74372       {
74373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74374       };
74375     } catch (std::exception& e) {
74376       {
74377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74378       };
74379     } catch (Dali::DaliException e) {
74380       {
74381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74382       };
74383     } catch (...) {
74384       {
74385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74386       };
74387     }
74388   }
74389
74390   jresult = result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74396   void * jresult ;
74397   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74398   unsigned int arg2 ;
74399   Dali::Actor result;
74400
74401   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74402   arg2 = (unsigned int)jarg2;
74403   {
74404     try {
74405       result = (arg1)->NewItem(arg2);
74406     } catch (std::out_of_range& e) {
74407       {
74408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74409       };
74410     } catch (std::exception& e) {
74411       {
74412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74413       };
74414     } catch (Dali::DaliException e) {
74415       {
74416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74417       };
74418     } catch (...) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74421       };
74422     }
74423   }
74424
74425   jresult = new Dali::Actor((const Dali::Actor &)result);
74426   return jresult;
74427 }
74428
74429
74430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74431   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74432   unsigned int arg2 ;
74433   Dali::Actor arg3 ;
74434   Dali::Actor *argp3 ;
74435
74436   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74437   arg2 = (unsigned int)jarg2;
74438   argp3 = (Dali::Actor *)jarg3;
74439   if (!argp3) {
74440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74441     return ;
74442   }
74443   arg3 = *argp3;
74444   {
74445     try {
74446       (arg1)->ItemReleased(arg2,arg3);
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74454       };
74455     } catch (Dali::DaliException e) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74462       };
74463     }
74464   }
74465
74466 }
74467
74468
74469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74470   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74471   unsigned int arg2 ;
74472   Dali::Actor arg3 ;
74473   Dali::Actor *argp3 ;
74474
74475   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74476   arg2 = (unsigned int)jarg2;
74477   argp3 = (Dali::Actor *)jarg3;
74478   if (!argp3) {
74479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74480     return ;
74481   }
74482   arg3 = *argp3;
74483   {
74484     try {
74485       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74493       };
74494     } catch (Dali::DaliException e) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74501       };
74502     }
74503   }
74504
74505 }
74506
74507
74508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74509   void * jresult ;
74510   Dali::Toolkit::ItemFactory *result = 0 ;
74511
74512   {
74513     try {
74514       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74515     } catch (std::out_of_range& e) {
74516       {
74517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74518       };
74519     } catch (std::exception& e) {
74520       {
74521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74522       };
74523     } catch (Dali::DaliException e) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74526       };
74527     } catch (...) {
74528       {
74529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74530       };
74531     }
74532   }
74533
74534   jresult = (void *)result;
74535   return jresult;
74536 }
74537
74538
74539 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) {
74540   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74541   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74542   if (director) {
74543     director->swig_connect_director(callback0, callback1, callback2);
74544   }
74545 }
74546
74547
74548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74549   int jresult ;
74550   int result;
74551
74552   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74553   jresult = (int)result;
74554   return jresult;
74555 }
74556
74557
74558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74559   int jresult ;
74560   int result;
74561
74562   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74563   jresult = (int)result;
74564   return jresult;
74565 }
74566
74567
74568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74569   int jresult ;
74570   int result;
74571
74572   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74573   jresult = (int)result;
74574   return jresult;
74575 }
74576
74577
74578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74579   int jresult ;
74580   int result;
74581
74582   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74583   jresult = (int)result;
74584   return jresult;
74585 }
74586
74587
74588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74589   int jresult ;
74590   int result;
74591
74592   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74593   jresult = (int)result;
74594   return jresult;
74595 }
74596
74597
74598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74599   int jresult ;
74600   int result;
74601
74602   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74603   jresult = (int)result;
74604   return jresult;
74605 }
74606
74607
74608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74609   int jresult ;
74610   int result;
74611
74612   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74613   jresult = (int)result;
74614   return jresult;
74615 }
74616
74617
74618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74619   int jresult ;
74620   int result;
74621
74622   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74623   jresult = (int)result;
74624   return jresult;
74625 }
74626
74627
74628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74629   int jresult ;
74630   int result;
74631
74632   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74633   jresult = (int)result;
74634   return jresult;
74635 }
74636
74637
74638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74639   int jresult ;
74640   int result;
74641
74642   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74643   jresult = (int)result;
74644   return jresult;
74645 }
74646
74647
74648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74649   int jresult ;
74650   int result;
74651
74652   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74653   jresult = (int)result;
74654   return jresult;
74655 }
74656
74657
74658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74659   void * jresult ;
74660   Dali::Toolkit::ItemView::Property *result = 0 ;
74661
74662   {
74663     try {
74664       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74665     } catch (std::out_of_range& e) {
74666       {
74667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (std::exception& e) {
74670       {
74671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74672       };
74673     } catch (Dali::DaliException e) {
74674       {
74675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74676       };
74677     } catch (...) {
74678       {
74679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74680       };
74681     }
74682   }
74683
74684   jresult = (void *)result;
74685   return jresult;
74686 }
74687
74688
74689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74690   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74691
74692   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74693   {
74694     try {
74695       delete arg1;
74696     } catch (std::out_of_range& e) {
74697       {
74698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74699       };
74700     } catch (std::exception& e) {
74701       {
74702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74703       };
74704     } catch (Dali::DaliException e) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74707       };
74708     } catch (...) {
74709       {
74710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74711       };
74712     }
74713   }
74714
74715 }
74716
74717
74718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74719   void * jresult ;
74720   Dali::Toolkit::ItemView *result = 0 ;
74721
74722   {
74723     try {
74724       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74725     } catch (std::out_of_range& e) {
74726       {
74727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74728       };
74729     } catch (std::exception& e) {
74730       {
74731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74732       };
74733     } catch (Dali::DaliException e) {
74734       {
74735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74736       };
74737     } catch (...) {
74738       {
74739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74740       };
74741     }
74742   }
74743
74744   jresult = (void *)result;
74745   return jresult;
74746 }
74747
74748
74749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74750   void * jresult ;
74751   Dali::Toolkit::ItemView *arg1 = 0 ;
74752   Dali::Toolkit::ItemView *result = 0 ;
74753
74754   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74755   if (!arg1) {
74756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74757     return 0;
74758   }
74759   {
74760     try {
74761       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74762     } catch (std::out_of_range& e) {
74763       {
74764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74765       };
74766     } catch (std::exception& e) {
74767       {
74768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74769       };
74770     } catch (Dali::DaliException e) {
74771       {
74772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74773       };
74774     } catch (...) {
74775       {
74776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74777       };
74778     }
74779   }
74780
74781   jresult = (void *)result;
74782   return jresult;
74783 }
74784
74785
74786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74787   void * jresult ;
74788   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74789   Dali::Toolkit::ItemView *arg2 = 0 ;
74790   Dali::Toolkit::ItemView *result = 0 ;
74791
74792   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74793   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74794   if (!arg2) {
74795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74796     return 0;
74797   }
74798   {
74799     try {
74800       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74801     } catch (std::out_of_range& e) {
74802       {
74803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74804       };
74805     } catch (std::exception& e) {
74806       {
74807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74808       };
74809     } catch (Dali::DaliException e) {
74810       {
74811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74812       };
74813     } catch (...) {
74814       {
74815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74816       };
74817     }
74818   }
74819
74820   jresult = (void *)result;
74821   return jresult;
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74827
74828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74829   {
74830     try {
74831       delete arg1;
74832     } catch (std::out_of_range& e) {
74833       {
74834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (std::exception& e) {
74837       {
74838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74839       };
74840     } catch (Dali::DaliException e) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74843       };
74844     } catch (...) {
74845       {
74846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74847       };
74848     }
74849   }
74850
74851 }
74852
74853
74854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74855   void * jresult ;
74856   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74857   Dali::Toolkit::ItemView result;
74858
74859   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74860   if (!arg1) {
74861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74862     return 0;
74863   }
74864   {
74865     try {
74866       result = Dali::Toolkit::ItemView::New(*arg1);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (Dali::DaliException e) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74878       };
74879     } catch (...) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74882       };
74883     }
74884   }
74885
74886   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74887   return jresult;
74888 }
74889
74890
74891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74892   void * jresult ;
74893   Dali::BaseHandle arg1 ;
74894   Dali::BaseHandle *argp1 ;
74895   Dali::Toolkit::ItemView result;
74896
74897   argp1 = (Dali::BaseHandle *)jarg1;
74898   if (!argp1) {
74899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74900     return 0;
74901   }
74902   arg1 = *argp1;
74903   {
74904     try {
74905       result = Dali::Toolkit::ItemView::DownCast(arg1);
74906     } catch (std::out_of_range& e) {
74907       {
74908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74909       };
74910     } catch (std::exception& e) {
74911       {
74912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74913       };
74914     } catch (Dali::DaliException e) {
74915       {
74916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74917       };
74918     } catch (...) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74921       };
74922     }
74923   }
74924
74925   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74926   return jresult;
74927 }
74928
74929
74930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
74931   unsigned int jresult ;
74932   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74933   unsigned int result;
74934
74935   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74936   {
74937     try {
74938       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
74939     } catch (std::out_of_range& e) {
74940       {
74941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74942       };
74943     } catch (std::exception& e) {
74944       {
74945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (Dali::DaliException e) {
74948       {
74949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74950       };
74951     } catch (...) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74954       };
74955     }
74956   }
74957
74958   jresult = result;
74959   return jresult;
74960 }
74961
74962
74963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
74964   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74965   Dali::Toolkit::ItemLayout *arg2 = 0 ;
74966
74967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74968   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
74969   if (!arg2) {
74970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
74971     return ;
74972   }
74973   {
74974     try {
74975       (arg1)->AddLayout(*arg2);
74976     } catch (std::out_of_range& e) {
74977       {
74978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74979       };
74980     } catch (std::exception& e) {
74981       {
74982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74983       };
74984     } catch (Dali::DaliException e) {
74985       {
74986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74987       };
74988     } catch (...) {
74989       {
74990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74991       };
74992     }
74993   }
74994
74995 }
74996
74997
74998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
74999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75000   unsigned int arg2 ;
75001
75002   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75003   arg2 = (unsigned int)jarg2;
75004   {
75005     try {
75006       (arg1)->RemoveLayout(arg2);
75007     } catch (std::out_of_range& e) {
75008       {
75009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75010       };
75011     } catch (std::exception& e) {
75012       {
75013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75014       };
75015     } catch (Dali::DaliException e) {
75016       {
75017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75018       };
75019     } catch (...) {
75020       {
75021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75022       };
75023     }
75024   }
75025
75026 }
75027
75028
75029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75030   void * jresult ;
75031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75032   unsigned int arg2 ;
75033   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75034
75035   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75036   arg2 = (unsigned int)jarg2;
75037   {
75038     try {
75039       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75040     } catch (std::out_of_range& e) {
75041       {
75042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (std::exception& e) {
75045       {
75046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75047       };
75048     } catch (Dali::DaliException e) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75051       };
75052     } catch (...) {
75053       {
75054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75055       };
75056     }
75057   }
75058
75059   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75060   return jresult;
75061 }
75062
75063
75064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75065   void * jresult ;
75066   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75067   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75068
75069   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75070   {
75071     try {
75072       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75080       };
75081     } catch (Dali::DaliException e) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75084       };
75085     } catch (...) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75088       };
75089     }
75090   }
75091
75092   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75093   return jresult;
75094 }
75095
75096
75097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75098   float jresult ;
75099   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75100   Dali::Toolkit::ItemId arg2 ;
75101   float result;
75102
75103   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75104   arg2 = (Dali::Toolkit::ItemId)jarg2;
75105   {
75106     try {
75107       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75108     } catch (std::out_of_range& e) {
75109       {
75110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (std::exception& e) {
75113       {
75114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (Dali::DaliException e) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75119       };
75120     } catch (...) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75123       };
75124     }
75125   }
75126
75127   jresult = result;
75128   return jresult;
75129 }
75130
75131
75132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75133   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75134   unsigned int arg2 ;
75135   Dali::Vector3 arg3 ;
75136   float arg4 ;
75137   Dali::Vector3 *argp3 ;
75138
75139   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75140   arg2 = (unsigned int)jarg2;
75141   argp3 = (Dali::Vector3 *)jarg3;
75142   if (!argp3) {
75143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75144     return ;
75145   }
75146   arg3 = *argp3;
75147   arg4 = (float)jarg4;
75148   {
75149     try {
75150       (arg1)->ActivateLayout(arg2,arg3,arg4);
75151     } catch (std::out_of_range& e) {
75152       {
75153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75154       };
75155     } catch (std::exception& e) {
75156       {
75157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75158       };
75159     } catch (Dali::DaliException e) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75162       };
75163     } catch (...) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75166       };
75167     }
75168   }
75169
75170 }
75171
75172
75173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75174   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75175
75176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75177   {
75178     try {
75179       (arg1)->DeactivateCurrentLayout();
75180     } catch (std::out_of_range& e) {
75181       {
75182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75183       };
75184     } catch (std::exception& e) {
75185       {
75186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75187       };
75188     } catch (Dali::DaliException e) {
75189       {
75190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75191       };
75192     } catch (...) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75195       };
75196     }
75197   }
75198
75199 }
75200
75201
75202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75204   float arg2 ;
75205
75206   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75207   arg2 = (float)jarg2;
75208   {
75209     try {
75210       (arg1)->SetMinimumSwipeSpeed(arg2);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75226       };
75227     }
75228   }
75229
75230 }
75231
75232
75233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75234   float jresult ;
75235   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75236   float result;
75237
75238   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75239   {
75240     try {
75241       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75242     } catch (std::out_of_range& e) {
75243       {
75244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75245       };
75246     } catch (std::exception& e) {
75247       {
75248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75249       };
75250     } catch (Dali::DaliException e) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75257       };
75258     }
75259   }
75260
75261   jresult = result;
75262   return jresult;
75263 }
75264
75265
75266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75267   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75268   float arg2 ;
75269
75270   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75271   arg2 = (float)jarg2;
75272   {
75273     try {
75274       (arg1)->SetMinimumSwipeDistance(arg2);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75282       };
75283     } catch (Dali::DaliException e) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75286       };
75287     } catch (...) {
75288       {
75289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75290       };
75291     }
75292   }
75293
75294 }
75295
75296
75297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75298   float jresult ;
75299   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75300   float result;
75301
75302   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75303   {
75304     try {
75305       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75306     } catch (std::out_of_range& e) {
75307       {
75308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75309       };
75310     } catch (std::exception& e) {
75311       {
75312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75313       };
75314     } catch (Dali::DaliException e) {
75315       {
75316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75317       };
75318     } catch (...) {
75319       {
75320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75321       };
75322     }
75323   }
75324
75325   jresult = result;
75326   return jresult;
75327 }
75328
75329
75330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75331   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75332   float arg2 ;
75333
75334   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75335   arg2 = (float)jarg2;
75336   {
75337     try {
75338       (arg1)->SetWheelScrollDistanceStep(arg2);
75339     } catch (std::out_of_range& e) {
75340       {
75341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (std::exception& e) {
75344       {
75345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75346       };
75347     } catch (Dali::DaliException e) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75350       };
75351     } catch (...) {
75352       {
75353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75354       };
75355     }
75356   }
75357
75358 }
75359
75360
75361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75362   float jresult ;
75363   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75364   float result;
75365
75366   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75367   {
75368     try {
75369       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75370     } catch (std::out_of_range& e) {
75371       {
75372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75373       };
75374     } catch (std::exception& e) {
75375       {
75376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75377       };
75378     } catch (Dali::DaliException e) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75385       };
75386     }
75387   }
75388
75389   jresult = result;
75390   return jresult;
75391 }
75392
75393
75394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75395   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75396   bool arg2 ;
75397
75398   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75399   arg2 = jarg2 ? true : false;
75400   {
75401     try {
75402       (arg1)->SetAnchoring(arg2);
75403     } catch (std::out_of_range& e) {
75404       {
75405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75406       };
75407     } catch (std::exception& e) {
75408       {
75409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75410       };
75411     } catch (Dali::DaliException e) {
75412       {
75413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75414       };
75415     } catch (...) {
75416       {
75417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75418       };
75419     }
75420   }
75421
75422 }
75423
75424 //// ========================= end of part 3 =============================
75425
75426 //// ========================== start part 4 ===============================
75427
75428
75429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75430   unsigned int jresult ;
75431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75432   bool result;
75433
75434   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75435   {
75436     try {
75437       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75438     } catch (std::out_of_range& e) {
75439       {
75440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75441       };
75442     } catch (std::exception& e) {
75443       {
75444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75445       };
75446     } catch (Dali::DaliException e) {
75447       {
75448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75449       };
75450     } catch (...) {
75451       {
75452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75453       };
75454     }
75455   }
75456
75457   jresult = result;
75458   return jresult;
75459 }
75460
75461
75462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75463   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75464   float arg2 ;
75465
75466   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75467   arg2 = (float)jarg2;
75468   {
75469     try {
75470       (arg1)->SetAnchoringDuration(arg2);
75471     } catch (std::out_of_range& e) {
75472       {
75473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75474       };
75475     } catch (std::exception& e) {
75476       {
75477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75478       };
75479     } catch (Dali::DaliException e) {
75480       {
75481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75482       };
75483     } catch (...) {
75484       {
75485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75486       };
75487     }
75488   }
75489
75490 }
75491
75492
75493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75494   float jresult ;
75495   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75496   float result;
75497
75498   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75499   {
75500     try {
75501       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75502     } catch (std::out_of_range& e) {
75503       {
75504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75505       };
75506     } catch (std::exception& e) {
75507       {
75508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75509       };
75510     } catch (Dali::DaliException e) {
75511       {
75512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75513       };
75514     } catch (...) {
75515       {
75516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75517       };
75518     }
75519   }
75520
75521   jresult = result;
75522   return jresult;
75523 }
75524
75525
75526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75528   Dali::Toolkit::ItemId arg2 ;
75529   float arg3 ;
75530
75531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75532   arg2 = (Dali::Toolkit::ItemId)jarg2;
75533   arg3 = (float)jarg3;
75534   {
75535     try {
75536       (arg1)->ScrollToItem(arg2,arg3);
75537     } catch (std::out_of_range& e) {
75538       {
75539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75540       };
75541     } catch (std::exception& e) {
75542       {
75543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75544       };
75545     } catch (Dali::DaliException e) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75548       };
75549     } catch (...) {
75550       {
75551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75552       };
75553     }
75554   }
75555
75556 }
75557
75558
75559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75561   float arg2 ;
75562
75563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75564   arg2 = (float)jarg2;
75565   {
75566     try {
75567       (arg1)->SetRefreshInterval(arg2);
75568     } catch (std::out_of_range& e) {
75569       {
75570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75571       };
75572     } catch (std::exception& e) {
75573       {
75574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75575       };
75576     } catch (Dali::DaliException e) {
75577       {
75578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75579       };
75580     } catch (...) {
75581       {
75582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75583       };
75584     }
75585   }
75586
75587 }
75588
75589
75590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75591   float jresult ;
75592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75593   float result;
75594
75595   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75596   {
75597     try {
75598       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75599     } catch (std::out_of_range& e) {
75600       {
75601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75602       };
75603     } catch (std::exception& e) {
75604       {
75605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75606       };
75607     } catch (Dali::DaliException e) {
75608       {
75609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75610       };
75611     } catch (...) {
75612       {
75613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75614       };
75615     }
75616   }
75617
75618   jresult = result;
75619   return jresult;
75620 }
75621
75622
75623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75624   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75625
75626   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75627   {
75628     try {
75629       (arg1)->Refresh();
75630     } catch (std::out_of_range& e) {
75631       {
75632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75633       };
75634     } catch (std::exception& e) {
75635       {
75636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75637       };
75638     } catch (Dali::DaliException e) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75645       };
75646     }
75647   }
75648
75649 }
75650
75651
75652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75653   void * jresult ;
75654   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75655   Dali::Toolkit::ItemId arg2 ;
75656   Dali::Actor result;
75657
75658   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75659   arg2 = (Dali::Toolkit::ItemId)jarg2;
75660   {
75661     try {
75662       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75670       };
75671     } catch (Dali::DaliException e) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75678       };
75679     }
75680   }
75681
75682   jresult = new Dali::Actor((const Dali::Actor &)result);
75683   return jresult;
75684 }
75685
75686
75687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75688   unsigned int jresult ;
75689   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75690   Dali::Actor arg2 ;
75691   Dali::Actor *argp2 ;
75692   Dali::Toolkit::ItemId result;
75693
75694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75695   argp2 = (Dali::Actor *)jarg2;
75696   if (!argp2) {
75697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75698     return 0;
75699   }
75700   arg2 = *argp2;
75701   {
75702     try {
75703       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75704     } catch (std::out_of_range& e) {
75705       {
75706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75707       };
75708     } catch (std::exception& e) {
75709       {
75710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75711       };
75712     } catch (Dali::DaliException e) {
75713       {
75714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75719       };
75720     }
75721   }
75722
75723   jresult = result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75729   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75730   Dali::Toolkit::Item arg2 ;
75731   float arg3 ;
75732   Dali::Toolkit::Item *argp2 ;
75733
75734   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75735   argp2 = (Dali::Toolkit::Item *)jarg2;
75736   if (!argp2) {
75737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75738     return ;
75739   }
75740   arg2 = *argp2;
75741   arg3 = (float)jarg3;
75742   {
75743     try {
75744       (arg1)->InsertItem(arg2,arg3);
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75752       };
75753     } catch (Dali::DaliException e) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75760       };
75761     }
75762   }
75763
75764 }
75765
75766
75767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75768   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75769   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75770   float arg3 ;
75771
75772   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75773   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75774   if (!arg2) {
75775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75776     return ;
75777   }
75778   arg3 = (float)jarg3;
75779   {
75780     try {
75781       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75782     } catch (std::out_of_range& e) {
75783       {
75784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75785       };
75786     } catch (std::exception& e) {
75787       {
75788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75789       };
75790     } catch (Dali::DaliException e) {
75791       {
75792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75793       };
75794     } catch (...) {
75795       {
75796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75797       };
75798     }
75799   }
75800
75801 }
75802
75803
75804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75805   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75806   Dali::Toolkit::ItemId arg2 ;
75807   float arg3 ;
75808
75809   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75810   arg2 = (Dali::Toolkit::ItemId)jarg2;
75811   arg3 = (float)jarg3;
75812   {
75813     try {
75814       (arg1)->RemoveItem(arg2,arg3);
75815     } catch (std::out_of_range& e) {
75816       {
75817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75818       };
75819     } catch (std::exception& e) {
75820       {
75821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75822       };
75823     } catch (Dali::DaliException e) {
75824       {
75825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75826       };
75827     } catch (...) {
75828       {
75829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75830       };
75831     }
75832   }
75833
75834 }
75835
75836
75837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75838   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75839   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75840   float arg3 ;
75841
75842   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75843   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75844   if (!arg2) {
75845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75846     return ;
75847   }
75848   arg3 = (float)jarg3;
75849   {
75850     try {
75851       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75852     } catch (std::out_of_range& e) {
75853       {
75854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75855       };
75856     } catch (std::exception& e) {
75857       {
75858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75859       };
75860     } catch (Dali::DaliException e) {
75861       {
75862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75863       };
75864     } catch (...) {
75865       {
75866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75867       };
75868     }
75869   }
75870
75871 }
75872
75873
75874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75875   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75876   Dali::Toolkit::Item arg2 ;
75877   float arg3 ;
75878   Dali::Toolkit::Item *argp2 ;
75879
75880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75881   argp2 = (Dali::Toolkit::Item *)jarg2;
75882   if (!argp2) {
75883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75884     return ;
75885   }
75886   arg2 = *argp2;
75887   arg3 = (float)jarg3;
75888   {
75889     try {
75890       (arg1)->ReplaceItem(arg2,arg3);
75891     } catch (std::out_of_range& e) {
75892       {
75893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (std::exception& e) {
75896       {
75897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75898       };
75899     } catch (Dali::DaliException e) {
75900       {
75901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75902       };
75903     } catch (...) {
75904       {
75905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75906       };
75907     }
75908   }
75909
75910 }
75911
75912
75913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75915   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75916   float arg3 ;
75917
75918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75919   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75920   if (!arg2) {
75921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75922     return ;
75923   }
75924   arg3 = (float)jarg3;
75925   {
75926     try {
75927       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75928     } catch (std::out_of_range& e) {
75929       {
75930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75931       };
75932     } catch (std::exception& e) {
75933       {
75934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75935       };
75936     } catch (Dali::DaliException e) {
75937       {
75938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75939       };
75940     } catch (...) {
75941       {
75942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75943       };
75944     }
75945   }
75946
75947 }
75948
75949
75950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
75951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75952   Dali::Vector3 *arg2 = 0 ;
75953
75954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75955   arg2 = (Dali::Vector3 *)jarg2;
75956   if (!arg2) {
75957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75958     return ;
75959   }
75960   {
75961     try {
75962       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
75963     } catch (std::out_of_range& e) {
75964       {
75965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75966       };
75967     } catch (std::exception& e) {
75968       {
75969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75970       };
75971     } catch (Dali::DaliException e) {
75972       {
75973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75974       };
75975     } catch (...) {
75976       {
75977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75978       };
75979     }
75980   }
75981
75982 }
75983
75984
75985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
75986   void * jresult ;
75987   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75988   Dali::Vector3 result;
75989
75990   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75991   {
75992     try {
75993       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
75994     } catch (std::out_of_range& e) {
75995       {
75996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75997       };
75998     } catch (std::exception& e) {
75999       {
76000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76001       };
76002     } catch (Dali::DaliException e) {
76003       {
76004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76005       };
76006     } catch (...) {
76007       {
76008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76009       };
76010     }
76011   }
76012
76013   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76014   return jresult;
76015 }
76016
76017
76018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76019   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76020   Dali::Vector3 *arg2 = 0 ;
76021
76022   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76023   arg2 = (Dali::Vector3 *)jarg2;
76024   if (!arg2) {
76025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76026     return ;
76027   }
76028   {
76029     try {
76030       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76031     } catch (std::out_of_range& e) {
76032       {
76033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76034       };
76035     } catch (std::exception& e) {
76036       {
76037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76038       };
76039     } catch (Dali::DaliException e) {
76040       {
76041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76042       };
76043     } catch (...) {
76044       {
76045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76046       };
76047     }
76048   }
76049
76050 }
76051
76052
76053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76054   void * jresult ;
76055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76056   Dali::Vector3 result;
76057
76058   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76059   {
76060     try {
76061       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76062     } catch (std::out_of_range& e) {
76063       {
76064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (std::exception& e) {
76067       {
76068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76069       };
76070     } catch (Dali::DaliException e) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76073       };
76074     } catch (...) {
76075       {
76076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76077       };
76078     }
76079   }
76080
76081   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76082   return jresult;
76083 }
76084
76085
76086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76087   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76088   Dali::Toolkit::ItemRange *arg2 = 0 ;
76089
76090   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76091   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76092   if (!arg2) {
76093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76094     return ;
76095   }
76096   {
76097     try {
76098       (arg1)->GetItemsRange(*arg2);
76099     } catch (std::out_of_range& e) {
76100       {
76101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76102       };
76103     } catch (std::exception& e) {
76104       {
76105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76106       };
76107     } catch (Dali::DaliException e) {
76108       {
76109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76110       };
76111     } catch (...) {
76112       {
76113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76114       };
76115     }
76116   }
76117
76118 }
76119
76120
76121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76122   void * jresult ;
76123   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76124   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76125
76126   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76127   {
76128     try {
76129       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76130     } catch (std::out_of_range& e) {
76131       {
76132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76133       };
76134     } catch (std::exception& e) {
76135       {
76136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76137       };
76138     } catch (Dali::DaliException e) {
76139       {
76140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76141       };
76142     } catch (...) {
76143       {
76144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76145       };
76146     }
76147   }
76148
76149   jresult = (void *)result;
76150   return jresult;
76151 }
76152
76153
76154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76155   Dali::Vector3 *arg1 = 0 ;
76156   PropertyInputContainer *arg2 = 0 ;
76157
76158   arg1 = (Dali::Vector3 *)jarg1;
76159   if (!arg1) {
76160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76161     return ;
76162   }
76163   arg2 = (PropertyInputContainer *)jarg2;
76164   if (!arg2) {
76165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76166     return ;
76167   }
76168   {
76169     try {
76170       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76171     } catch (std::out_of_range& e) {
76172       {
76173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76174       };
76175     } catch (std::exception& e) {
76176       {
76177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76178       };
76179     } catch (Dali::DaliException e) {
76180       {
76181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76182       };
76183     } catch (...) {
76184       {
76185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76186       };
76187     }
76188   }
76189
76190 }
76191
76192
76193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76194   Dali::Vector3 *arg1 = 0 ;
76195   PropertyInputContainer *arg2 = 0 ;
76196
76197   arg1 = (Dali::Vector3 *)jarg1;
76198   if (!arg1) {
76199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76200     return ;
76201   }
76202   arg2 = (PropertyInputContainer *)jarg2;
76203   if (!arg2) {
76204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76205     return ;
76206   }
76207   {
76208     try {
76209       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76210     } catch (std::out_of_range& e) {
76211       {
76212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76213       };
76214     } catch (std::exception& e) {
76215       {
76216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76217       };
76218     } catch (Dali::DaliException e) {
76219       {
76220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76221       };
76222     } catch (...) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76225       };
76226     }
76227   }
76228
76229 }
76230
76231
76232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76233   void * jresult ;
76234   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76235
76236   {
76237     try {
76238       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76239     } catch (std::out_of_range& e) {
76240       {
76241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76242       };
76243     } catch (std::exception& e) {
76244       {
76245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76246       };
76247     } catch (Dali::DaliException e) {
76248       {
76249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76250       };
76251     } catch (...) {
76252       {
76253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76254       };
76255     }
76256   }
76257
76258   jresult = (void *)result;
76259   return jresult;
76260 }
76261
76262
76263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76264   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76265
76266   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76267   {
76268     try {
76269       delete arg1;
76270     } catch (std::out_of_range& e) {
76271       {
76272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76273       };
76274     } catch (std::exception& e) {
76275       {
76276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76277       };
76278     } catch (Dali::DaliException e) {
76279       {
76280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76281       };
76282     } catch (...) {
76283       {
76284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76285       };
76286     }
76287   }
76288
76289 }
76290
76291
76292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76293   void * jresult ;
76294   Dali::Path arg1 ;
76295   Dali::Vector3 *arg2 = 0 ;
76296   Dali::Property::Index arg3 ;
76297   Dali::Vector3 *arg4 = 0 ;
76298   unsigned int arg5 ;
76299   Dali::Path *argp1 ;
76300   Dali::Toolkit::ScrollViewPagePathEffect result;
76301
76302   argp1 = (Dali::Path *)jarg1;
76303   if (!argp1) {
76304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76305     return 0;
76306   }
76307   arg1 = *argp1;
76308   arg2 = (Dali::Vector3 *)jarg2;
76309   if (!arg2) {
76310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76311     return 0;
76312   }
76313   arg3 = (Dali::Property::Index)jarg3;
76314   arg4 = (Dali::Vector3 *)jarg4;
76315   if (!arg4) {
76316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76317     return 0;
76318   }
76319   arg5 = (unsigned int)jarg5;
76320   {
76321     try {
76322       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76323     } catch (std::out_of_range& e) {
76324       {
76325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (std::exception& e) {
76328       {
76329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76330       };
76331     } catch (Dali::DaliException e) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76334       };
76335     } catch (...) {
76336       {
76337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76338       };
76339     }
76340   }
76341
76342   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76343   return jresult;
76344 }
76345
76346
76347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76348   void * jresult ;
76349   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76350
76351   {
76352     try {
76353       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76354     } catch (std::out_of_range& e) {
76355       {
76356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76357       };
76358     } catch (std::exception& e) {
76359       {
76360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76361       };
76362     } catch (Dali::DaliException e) {
76363       {
76364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76365       };
76366     } catch (...) {
76367       {
76368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76369       };
76370     }
76371   }
76372
76373   jresult = (void *)result;
76374   return jresult;
76375 }
76376
76377
76378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76379   void * jresult ;
76380   Dali::BaseHandle arg1 ;
76381   Dali::BaseHandle *argp1 ;
76382   Dali::Toolkit::ScrollViewPagePathEffect result;
76383
76384   argp1 = (Dali::BaseHandle *)jarg1;
76385   if (!argp1) {
76386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76387     return 0;
76388   }
76389   arg1 = *argp1;
76390   {
76391     try {
76392       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76393     } catch (std::out_of_range& e) {
76394       {
76395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76396       };
76397     } catch (std::exception& e) {
76398       {
76399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76400       };
76401     } catch (Dali::DaliException e) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76404       };
76405     } catch (...) {
76406       {
76407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76408       };
76409     }
76410   }
76411
76412   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76413   return jresult;
76414 }
76415
76416
76417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76418   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76419   Dali::Actor arg2 ;
76420   unsigned int arg3 ;
76421   Dali::Actor *argp2 ;
76422
76423   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76424   argp2 = (Dali::Actor *)jarg2;
76425   if (!argp2) {
76426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76427     return ;
76428   }
76429   arg2 = *argp2;
76430   arg3 = (unsigned int)jarg3;
76431   {
76432     try {
76433       (arg1)->ApplyToPage(arg2,arg3);
76434     } catch (std::out_of_range& e) {
76435       {
76436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76437       };
76438     } catch (std::exception& e) {
76439       {
76440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76441       };
76442     } catch (Dali::DaliException e) {
76443       {
76444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76445       };
76446     } catch (...) {
76447       {
76448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76449       };
76450     }
76451   }
76452
76453 }
76454
76455
76456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76457   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76458
76459   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76460   {
76461     try {
76462       delete arg1;
76463     } catch (std::out_of_range& e) {
76464       {
76465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76466       };
76467     } catch (std::exception& e) {
76468       {
76469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76470       };
76471     } catch (Dali::DaliException e) {
76472       {
76473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76474       };
76475     } catch (...) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76478       };
76479     }
76480   }
76481
76482 }
76483
76484
76485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76486   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76487   Dali::Toolkit::ClampState arg2 ;
76488
76489   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76490   arg2 = (Dali::Toolkit::ClampState)jarg2;
76491   if (arg1) (arg1)->x = arg2;
76492 }
76493
76494
76495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76496   int jresult ;
76497   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76498   Dali::Toolkit::ClampState result;
76499
76500   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76501   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76502   jresult = (int)result;
76503   return jresult;
76504 }
76505
76506
76507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76508   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76509   Dali::Toolkit::ClampState arg2 ;
76510
76511   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76512   arg2 = (Dali::Toolkit::ClampState)jarg2;
76513   if (arg1) (arg1)->y = arg2;
76514 }
76515
76516
76517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76518   int jresult ;
76519   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76520   Dali::Toolkit::ClampState result;
76521
76522   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76523   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76524   jresult = (int)result;
76525   return jresult;
76526 }
76527
76528
76529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76530   void * jresult ;
76531   Dali::Toolkit::ClampState2D *result = 0 ;
76532
76533   {
76534     try {
76535       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76536     } catch (std::out_of_range& e) {
76537       {
76538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76539       };
76540     } catch (std::exception& e) {
76541       {
76542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76543       };
76544     } catch (Dali::DaliException e) {
76545       {
76546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76547       };
76548     } catch (...) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76551       };
76552     }
76553   }
76554
76555   jresult = (void *)result;
76556   return jresult;
76557 }
76558
76559
76560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76561   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76562
76563   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76564   {
76565     try {
76566       delete arg1;
76567     } catch (std::out_of_range& e) {
76568       {
76569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76570       };
76571     } catch (std::exception& e) {
76572       {
76573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76574       };
76575     } catch (Dali::DaliException e) {
76576       {
76577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76578       };
76579     } catch (...) {
76580       {
76581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76582       };
76583     }
76584   }
76585
76586 }
76587
76588
76589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76590   void * jresult ;
76591   float arg1 ;
76592   float arg2 ;
76593   bool arg3 ;
76594   Dali::Toolkit::RulerDomain *result = 0 ;
76595
76596   arg1 = (float)jarg1;
76597   arg2 = (float)jarg2;
76598   arg3 = jarg3 ? true : false;
76599   {
76600     try {
76601       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76602     } catch (std::out_of_range& e) {
76603       {
76604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76605       };
76606     } catch (std::exception& e) {
76607       {
76608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76609       };
76610     } catch (Dali::DaliException e) {
76611       {
76612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76613       };
76614     } catch (...) {
76615       {
76616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76617       };
76618     }
76619   }
76620
76621   jresult = (void *)result;
76622   return jresult;
76623 }
76624
76625
76626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76627   void * jresult ;
76628   float arg1 ;
76629   float arg2 ;
76630   Dali::Toolkit::RulerDomain *result = 0 ;
76631
76632   arg1 = (float)jarg1;
76633   arg2 = (float)jarg2;
76634   {
76635     try {
76636       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76637     } catch (std::out_of_range& e) {
76638       {
76639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76640       };
76641     } catch (std::exception& e) {
76642       {
76643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76644       };
76645     } catch (Dali::DaliException e) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76648       };
76649     } catch (...) {
76650       {
76651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76652       };
76653     }
76654   }
76655
76656   jresult = (void *)result;
76657   return jresult;
76658 }
76659
76660
76661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76662   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76663   float arg2 ;
76664
76665   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76666   arg2 = (float)jarg2;
76667   if (arg1) (arg1)->min = arg2;
76668 }
76669
76670
76671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76672   float jresult ;
76673   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76674   float result;
76675
76676   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76677   result = (float) ((arg1)->min);
76678   jresult = result;
76679   return jresult;
76680 }
76681
76682
76683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76684   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76685   float arg2 ;
76686
76687   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76688   arg2 = (float)jarg2;
76689   if (arg1) (arg1)->max = arg2;
76690 }
76691
76692
76693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76694   float jresult ;
76695   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76696   float result;
76697
76698   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76699   result = (float) ((arg1)->max);
76700   jresult = result;
76701   return jresult;
76702 }
76703
76704
76705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76706   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76707   bool arg2 ;
76708
76709   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76710   arg2 = jarg2 ? true : false;
76711   if (arg1) (arg1)->enabled = arg2;
76712 }
76713
76714
76715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76716   unsigned int jresult ;
76717   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76718   bool result;
76719
76720   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76721   result = (bool) ((arg1)->enabled);
76722   jresult = result;
76723   return jresult;
76724 }
76725
76726
76727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76728   float jresult ;
76729   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76730   float arg2 ;
76731   float arg3 ;
76732   float arg4 ;
76733   float result;
76734
76735   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76736   arg2 = (float)jarg2;
76737   arg3 = (float)jarg3;
76738   arg4 = (float)jarg4;
76739   {
76740     try {
76741       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76742     } catch (std::out_of_range& e) {
76743       {
76744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76745       };
76746     } catch (std::exception& e) {
76747       {
76748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76749       };
76750     } catch (Dali::DaliException e) {
76751       {
76752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76753       };
76754     } catch (...) {
76755       {
76756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76757       };
76758     }
76759   }
76760
76761   jresult = result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76767   float jresult ;
76768   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76769   float arg2 ;
76770   float arg3 ;
76771   float result;
76772
76773   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76774   arg2 = (float)jarg2;
76775   arg3 = (float)jarg3;
76776   {
76777     try {
76778       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76779     } catch (std::out_of_range& e) {
76780       {
76781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76782       };
76783     } catch (std::exception& e) {
76784       {
76785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76786       };
76787     } catch (Dali::DaliException e) {
76788       {
76789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76790       };
76791     } catch (...) {
76792       {
76793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76794       };
76795     }
76796   }
76797
76798   jresult = result;
76799   return jresult;
76800 }
76801
76802
76803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76804   float jresult ;
76805   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76806   float arg2 ;
76807   float result;
76808
76809   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76810   arg2 = (float)jarg2;
76811   {
76812     try {
76813       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76814     } catch (std::out_of_range& e) {
76815       {
76816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76817       };
76818     } catch (std::exception& e) {
76819       {
76820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76821       };
76822     } catch (Dali::DaliException e) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76825       };
76826     } catch (...) {
76827       {
76828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76829       };
76830     }
76831   }
76832
76833   jresult = result;
76834   return jresult;
76835 }
76836
76837
76838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76839   float jresult ;
76840   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76841   float arg2 ;
76842   float arg3 ;
76843   float arg4 ;
76844   Dali::Toolkit::ClampState *arg5 = 0 ;
76845   float result;
76846
76847   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76848   arg2 = (float)jarg2;
76849   arg3 = (float)jarg3;
76850   arg4 = (float)jarg4;
76851   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76852   if (!arg5) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76854     return 0;
76855   }
76856   {
76857     try {
76858       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76866       };
76867     } catch (Dali::DaliException e) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76870       };
76871     } catch (...) {
76872       {
76873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76874       };
76875     }
76876   }
76877
76878   jresult = result;
76879   return jresult;
76880 }
76881
76882
76883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76884   float jresult ;
76885   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76886   float result;
76887
76888   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76889   {
76890     try {
76891       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76892     } catch (std::out_of_range& e) {
76893       {
76894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76895       };
76896     } catch (std::exception& e) {
76897       {
76898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76899       };
76900     } catch (Dali::DaliException e) {
76901       {
76902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76903       };
76904     } catch (...) {
76905       {
76906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76907       };
76908     }
76909   }
76910
76911   jresult = result;
76912   return jresult;
76913 }
76914
76915
76916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76917   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76918
76919   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76920   {
76921     try {
76922       delete arg1;
76923     } catch (std::out_of_range& e) {
76924       {
76925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76926       };
76927     } catch (std::exception& e) {
76928       {
76929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76930       };
76931     } catch (Dali::DaliException e) {
76932       {
76933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76934       };
76935     } catch (...) {
76936       {
76937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76938       };
76939     }
76940   }
76941
76942 }
76943
76944
76945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
76946   float jresult ;
76947   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76948   float arg2 ;
76949   float arg3 ;
76950   float result;
76951
76952   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76953   arg2 = (float)jarg2;
76954   arg3 = (float)jarg3;
76955   {
76956     try {
76957       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
76958     } catch (std::out_of_range& e) {
76959       {
76960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76961       };
76962     } catch (std::exception& e) {
76963       {
76964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76965       };
76966     } catch (Dali::DaliException e) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76969       };
76970     } catch (...) {
76971       {
76972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76973       };
76974     }
76975   }
76976
76977   jresult = result;
76978   return jresult;
76979 }
76980
76981
76982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
76983   float jresult ;
76984   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76985   float arg2 ;
76986   float result;
76987
76988   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76989   arg2 = (float)jarg2;
76990   {
76991     try {
76992       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
76993     } catch (std::out_of_range& e) {
76994       {
76995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76996       };
76997     } catch (std::exception& e) {
76998       {
76999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77000       };
77001     } catch (Dali::DaliException e) {
77002       {
77003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77004       };
77005     } catch (...) {
77006       {
77007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77008       };
77009     }
77010   }
77011
77012   jresult = result;
77013   return jresult;
77014 }
77015
77016
77017 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77018   float jresult ;
77019   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77020   unsigned int arg2 ;
77021   unsigned int *arg3 = 0 ;
77022   bool arg4 ;
77023   float result;
77024
77025   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77026   arg2 = (unsigned int)jarg2;
77027   arg3 = (unsigned int *)jarg3;
77028   arg4 = jarg4 ? true : false;
77029   {
77030     try {
77031       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77032     } catch (std::out_of_range& e) {
77033       {
77034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77035       };
77036     } catch (std::exception& e) {
77037       {
77038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77039       };
77040     } catch (Dali::DaliException e) {
77041       {
77042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77043       };
77044     } catch (...) {
77045       {
77046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77047       };
77048     }
77049   }
77050
77051   jresult = result;
77052   return jresult;
77053 }
77054
77055
77056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77057   unsigned int jresult ;
77058   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77059   float arg2 ;
77060   bool arg3 ;
77061   unsigned int result;
77062
77063   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77064   arg2 = (float)jarg2;
77065   arg3 = jarg3 ? true : false;
77066   {
77067     try {
77068       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77069     } catch (std::out_of_range& e) {
77070       {
77071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77072       };
77073     } catch (std::exception& e) {
77074       {
77075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77076       };
77077     } catch (Dali::DaliException e) {
77078       {
77079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77080       };
77081     } catch (...) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77084       };
77085     }
77086   }
77087
77088   jresult = result;
77089   return jresult;
77090 }
77091
77092
77093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77094   unsigned int jresult ;
77095   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77096   unsigned int result;
77097
77098   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77099   {
77100     try {
77101       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77102     } catch (std::out_of_range& e) {
77103       {
77104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77105       };
77106     } catch (std::exception& e) {
77107       {
77108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77109       };
77110     } catch (Dali::DaliException e) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77113       };
77114     } catch (...) {
77115       {
77116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77117       };
77118     }
77119   }
77120
77121   jresult = result;
77122   return jresult;
77123 }
77124
77125
77126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77127   int jresult ;
77128   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77129   Dali::Toolkit::Ruler::RulerType result;
77130
77131   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77132   {
77133     try {
77134       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77135     } catch (std::out_of_range& e) {
77136       {
77137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77138       };
77139     } catch (std::exception& e) {
77140       {
77141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77142       };
77143     } catch (Dali::DaliException e) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77150       };
77151     }
77152   }
77153
77154   jresult = (int)result;
77155   return jresult;
77156 }
77157
77158
77159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77160   unsigned int jresult ;
77161   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77162   bool result;
77163
77164   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77165   {
77166     try {
77167       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77168     } catch (std::out_of_range& e) {
77169       {
77170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77171       };
77172     } catch (std::exception& e) {
77173       {
77174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77175       };
77176     } catch (Dali::DaliException e) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77179       };
77180     } catch (...) {
77181       {
77182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77183       };
77184     }
77185   }
77186
77187   jresult = result;
77188   return jresult;
77189 }
77190
77191
77192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77193   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77194
77195   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77196   {
77197     try {
77198       (arg1)->Enable();
77199     } catch (std::out_of_range& e) {
77200       {
77201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77202       };
77203     } catch (std::exception& e) {
77204       {
77205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (Dali::DaliException e) {
77208       {
77209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77210       };
77211     } catch (...) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77214       };
77215     }
77216   }
77217
77218 }
77219
77220
77221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77222   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77223
77224   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77225   {
77226     try {
77227       (arg1)->Disable();
77228     } catch (std::out_of_range& e) {
77229       {
77230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77231       };
77232     } catch (std::exception& e) {
77233       {
77234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77235       };
77236     } catch (Dali::DaliException e) {
77237       {
77238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77239       };
77240     } catch (...) {
77241       {
77242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77243       };
77244     }
77245   }
77246
77247 }
77248
77249
77250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77251   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77252   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77253   Dali::Toolkit::RulerDomain *argp2 ;
77254
77255   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77256   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77257   if (!argp2) {
77258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77259     return ;
77260   }
77261   arg2 = *argp2;
77262   {
77263     try {
77264       (arg1)->SetDomain(arg2);
77265     } catch (std::out_of_range& e) {
77266       {
77267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77268       };
77269     } catch (std::exception& e) {
77270       {
77271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77272       };
77273     } catch (Dali::DaliException e) {
77274       {
77275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77276       };
77277     } catch (...) {
77278       {
77279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77280       };
77281     }
77282   }
77283
77284 }
77285
77286
77287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77288   void * jresult ;
77289   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77290   Dali::Toolkit::RulerDomain *result = 0 ;
77291
77292   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77293   {
77294     try {
77295       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77296     } catch (std::out_of_range& e) {
77297       {
77298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77299       };
77300     } catch (std::exception& e) {
77301       {
77302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77303       };
77304     } catch (Dali::DaliException e) {
77305       {
77306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77307       };
77308     } catch (...) {
77309       {
77310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77311       };
77312     }
77313   }
77314
77315   jresult = (void *)result;
77316   return jresult;
77317 }
77318
77319
77320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77321   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77322
77323   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77324   {
77325     try {
77326       (arg1)->DisableDomain();
77327     } catch (std::out_of_range& e) {
77328       {
77329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77330       };
77331     } catch (std::exception& e) {
77332       {
77333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77334       };
77335     } catch (Dali::DaliException e) {
77336       {
77337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77338       };
77339     } catch (...) {
77340       {
77341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77342       };
77343     }
77344   }
77345
77346 }
77347
77348
77349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77350   float jresult ;
77351   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77352   float arg2 ;
77353   float arg3 ;
77354   float arg4 ;
77355   float result;
77356
77357   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77358   arg2 = (float)jarg2;
77359   arg3 = (float)jarg3;
77360   arg4 = (float)jarg4;
77361   {
77362     try {
77363       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77364     } catch (std::out_of_range& e) {
77365       {
77366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77367       };
77368     } catch (std::exception& e) {
77369       {
77370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77371       };
77372     } catch (Dali::DaliException e) {
77373       {
77374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77375       };
77376     } catch (...) {
77377       {
77378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77379       };
77380     }
77381   }
77382
77383   jresult = result;
77384   return jresult;
77385 }
77386
77387
77388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77389   float jresult ;
77390   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77391   float arg2 ;
77392   float arg3 ;
77393   float result;
77394
77395   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77396   arg2 = (float)jarg2;
77397   arg3 = (float)jarg3;
77398   {
77399     try {
77400       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77401     } catch (std::out_of_range& e) {
77402       {
77403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77404       };
77405     } catch (std::exception& e) {
77406       {
77407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77408       };
77409     } catch (Dali::DaliException e) {
77410       {
77411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77412       };
77413     } catch (...) {
77414       {
77415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77416       };
77417     }
77418   }
77419
77420   jresult = result;
77421   return jresult;
77422 }
77423
77424
77425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77426   float jresult ;
77427   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77428   float arg2 ;
77429   float result;
77430
77431   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77432   arg2 = (float)jarg2;
77433   {
77434     try {
77435       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77436     } catch (std::out_of_range& e) {
77437       {
77438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77439       };
77440     } catch (std::exception& e) {
77441       {
77442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77443       };
77444     } catch (Dali::DaliException e) {
77445       {
77446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77447       };
77448     } catch (...) {
77449       {
77450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77451       };
77452     }
77453   }
77454
77455   jresult = result;
77456   return jresult;
77457 }
77458
77459
77460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77461   float jresult ;
77462   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77463   float arg2 ;
77464   float arg3 ;
77465   float arg4 ;
77466   Dali::Toolkit::ClampState *arg5 = 0 ;
77467   float result;
77468
77469   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77470   arg2 = (float)jarg2;
77471   arg3 = (float)jarg3;
77472   arg4 = (float)jarg4;
77473   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77474   if (!arg5) {
77475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77476     return 0;
77477   }
77478   {
77479     try {
77480       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77481     } catch (std::out_of_range& e) {
77482       {
77483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77484       };
77485     } catch (std::exception& e) {
77486       {
77487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77488       };
77489     } catch (Dali::DaliException e) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77492       };
77493     } catch (...) {
77494       {
77495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77496       };
77497     }
77498   }
77499
77500   jresult = result;
77501   return jresult;
77502 }
77503
77504
77505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77506   float jresult ;
77507   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77508   float arg2 ;
77509   float arg3 ;
77510   float arg4 ;
77511   float arg5 ;
77512   float result;
77513
77514   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77515   arg2 = (float)jarg2;
77516   arg3 = (float)jarg3;
77517   arg4 = (float)jarg4;
77518   arg5 = (float)jarg5;
77519   {
77520     try {
77521       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77522     } catch (std::out_of_range& e) {
77523       {
77524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77525       };
77526     } catch (std::exception& e) {
77527       {
77528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77529       };
77530     } catch (Dali::DaliException e) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77533       };
77534     } catch (...) {
77535       {
77536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77537       };
77538     }
77539   }
77540
77541   jresult = result;
77542   return jresult;
77543 }
77544
77545
77546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77547   float jresult ;
77548   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77549   float arg2 ;
77550   float arg3 ;
77551   float arg4 ;
77552   float result;
77553
77554   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77555   arg2 = (float)jarg2;
77556   arg3 = (float)jarg3;
77557   arg4 = (float)jarg4;
77558   {
77559     try {
77560       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77561     } catch (std::out_of_range& e) {
77562       {
77563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77564       };
77565     } catch (std::exception& e) {
77566       {
77567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77568       };
77569     } catch (Dali::DaliException e) {
77570       {
77571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77572       };
77573     } catch (...) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77576       };
77577     }
77578   }
77579
77580   jresult = result;
77581   return jresult;
77582 }
77583
77584
77585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77586   float jresult ;
77587   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77588   float arg2 ;
77589   float arg3 ;
77590   float result;
77591
77592   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77593   arg2 = (float)jarg2;
77594   arg3 = (float)jarg3;
77595   {
77596     try {
77597       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77598     } catch (std::out_of_range& e) {
77599       {
77600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77601       };
77602     } catch (std::exception& e) {
77603       {
77604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77605       };
77606     } catch (Dali::DaliException e) {
77607       {
77608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77609       };
77610     } catch (...) {
77611       {
77612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77613       };
77614     }
77615   }
77616
77617   jresult = result;
77618   return jresult;
77619 }
77620
77621
77622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77623   float jresult ;
77624   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77625   float arg2 ;
77626   float result;
77627
77628   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77629   arg2 = (float)jarg2;
77630   {
77631     try {
77632       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77633     } catch (std::out_of_range& e) {
77634       {
77635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77636       };
77637     } catch (std::exception& e) {
77638       {
77639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77640       };
77641     } catch (Dali::DaliException e) {
77642       {
77643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77644       };
77645     } catch (...) {
77646       {
77647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77648       };
77649     }
77650   }
77651
77652   jresult = result;
77653   return jresult;
77654 }
77655
77656
77657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77658   float jresult ;
77659   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77660   float arg2 ;
77661   float arg3 ;
77662   float arg4 ;
77663   float arg5 ;
77664   Dali::Toolkit::ClampState *arg6 = 0 ;
77665   float result;
77666
77667   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77668   arg2 = (float)jarg2;
77669   arg3 = (float)jarg3;
77670   arg4 = (float)jarg4;
77671   arg5 = (float)jarg5;
77672   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77673   if (!arg6) {
77674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77675     return 0;
77676   }
77677   {
77678     try {
77679       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77680     } catch (std::out_of_range& e) {
77681       {
77682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (std::exception& e) {
77685       {
77686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77687       };
77688     } catch (Dali::DaliException e) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77691       };
77692     } catch (...) {
77693       {
77694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77695       };
77696     }
77697   }
77698
77699   jresult = result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77705   void * jresult ;
77706   Dali::Toolkit::DefaultRuler *result = 0 ;
77707
77708   {
77709     try {
77710       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77718       };
77719     } catch (Dali::DaliException e) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77722       };
77723     } catch (...) {
77724       {
77725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77726       };
77727     }
77728   }
77729
77730   jresult = (void *)result;
77731   return jresult;
77732 }
77733
77734
77735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77736   float jresult ;
77737   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77738   float arg2 ;
77739   float arg3 ;
77740   float result;
77741
77742   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77743   arg2 = (float)jarg2;
77744   arg3 = (float)jarg3;
77745   {
77746     try {
77747       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77748     } catch (std::out_of_range& e) {
77749       {
77750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (std::exception& e) {
77753       {
77754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77755       };
77756     } catch (Dali::DaliException e) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77759       };
77760     } catch (...) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77763       };
77764     }
77765   }
77766
77767   jresult = result;
77768   return jresult;
77769 }
77770
77771
77772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77773   float jresult ;
77774   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77775   unsigned int arg2 ;
77776   unsigned int *arg3 = 0 ;
77777   bool arg4 ;
77778   float result;
77779
77780   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77781   arg2 = (unsigned int)jarg2;
77782   arg3 = (unsigned int *)jarg3;
77783   arg4 = jarg4 ? true : false;
77784   {
77785     try {
77786       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77787     } catch (std::out_of_range& e) {
77788       {
77789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77790       };
77791     } catch (std::exception& e) {
77792       {
77793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77794       };
77795     } catch (Dali::DaliException e) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77802       };
77803     }
77804   }
77805
77806   jresult = result;
77807   return jresult;
77808 }
77809
77810
77811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77812   unsigned int jresult ;
77813   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77814   float arg2 ;
77815   bool arg3 ;
77816   unsigned int result;
77817
77818   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77819   arg2 = (float)jarg2;
77820   arg3 = jarg3 ? true : false;
77821   {
77822     try {
77823       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77824     } catch (std::out_of_range& e) {
77825       {
77826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77827       };
77828     } catch (std::exception& e) {
77829       {
77830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77831       };
77832     } catch (Dali::DaliException e) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77835       };
77836     } catch (...) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77839       };
77840     }
77841   }
77842
77843   jresult = result;
77844   return jresult;
77845 }
77846
77847
77848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77849   unsigned int jresult ;
77850   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77851   unsigned int result;
77852
77853   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77854   {
77855     try {
77856       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77857     } catch (std::out_of_range& e) {
77858       {
77859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77860       };
77861     } catch (std::exception& e) {
77862       {
77863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77864       };
77865     } catch (Dali::DaliException e) {
77866       {
77867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77868       };
77869     } catch (...) {
77870       {
77871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77872       };
77873     }
77874   }
77875
77876   jresult = result;
77877   return jresult;
77878 }
77879
77880
77881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77882   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77883
77884   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77885   {
77886     try {
77887       delete arg1;
77888     } catch (std::out_of_range& e) {
77889       {
77890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77891       };
77892     } catch (std::exception& e) {
77893       {
77894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77895       };
77896     } catch (Dali::DaliException e) {
77897       {
77898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77899       };
77900     } catch (...) {
77901       {
77902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77903       };
77904     }
77905   }
77906
77907 }
77908
77909
77910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77911   void * jresult ;
77912   float arg1 ;
77913   Dali::Toolkit::FixedRuler *result = 0 ;
77914
77915   arg1 = (float)jarg1;
77916   {
77917     try {
77918       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77919     } catch (std::out_of_range& e) {
77920       {
77921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77922       };
77923     } catch (std::exception& e) {
77924       {
77925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77926       };
77927     } catch (Dali::DaliException e) {
77928       {
77929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77930       };
77931     } catch (...) {
77932       {
77933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77934       };
77935     }
77936   }
77937
77938   jresult = (void *)result;
77939   return jresult;
77940 }
77941
77942
77943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
77944   void * jresult ;
77945   Dali::Toolkit::FixedRuler *result = 0 ;
77946
77947   {
77948     try {
77949       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
77950     } catch (std::out_of_range& e) {
77951       {
77952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77953       };
77954     } catch (std::exception& e) {
77955       {
77956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77957       };
77958     } catch (Dali::DaliException e) {
77959       {
77960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77961       };
77962     } catch (...) {
77963       {
77964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77965       };
77966     }
77967   }
77968
77969   jresult = (void *)result;
77970   return jresult;
77971 }
77972
77973
77974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77975   float jresult ;
77976   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77977   float arg2 ;
77978   float arg3 ;
77979   float result;
77980
77981   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77982   arg2 = (float)jarg2;
77983   arg3 = (float)jarg3;
77984   {
77985     try {
77986       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
77987     } catch (std::out_of_range& e) {
77988       {
77989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77990       };
77991     } catch (std::exception& e) {
77992       {
77993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (Dali::DaliException e) {
77996       {
77997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77998       };
77999     } catch (...) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78002       };
78003     }
78004   }
78005
78006   jresult = result;
78007   return jresult;
78008 }
78009
78010
78011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78012   float jresult ;
78013   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78014   unsigned int arg2 ;
78015   unsigned int *arg3 = 0 ;
78016   bool arg4 ;
78017   float result;
78018
78019   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78020   arg2 = (unsigned int)jarg2;
78021   arg3 = (unsigned int *)jarg3;
78022   arg4 = jarg4 ? true : false;
78023   {
78024     try {
78025       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78026     } catch (std::out_of_range& e) {
78027       {
78028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78029       };
78030     } catch (std::exception& e) {
78031       {
78032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78033       };
78034     } catch (Dali::DaliException e) {
78035       {
78036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78037       };
78038     } catch (...) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78041       };
78042     }
78043   }
78044
78045   jresult = result;
78046   return jresult;
78047 }
78048
78049
78050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78051   unsigned int jresult ;
78052   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78053   float arg2 ;
78054   bool arg3 ;
78055   unsigned int result;
78056
78057   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78058   arg2 = (float)jarg2;
78059   arg3 = jarg3 ? true : false;
78060   {
78061     try {
78062       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78063     } catch (std::out_of_range& e) {
78064       {
78065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78066       };
78067     } catch (std::exception& e) {
78068       {
78069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78070       };
78071     } catch (Dali::DaliException e) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78074       };
78075     } catch (...) {
78076       {
78077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78078       };
78079     }
78080   }
78081
78082   jresult = result;
78083   return jresult;
78084 }
78085
78086
78087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78088   unsigned int jresult ;
78089   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78090   unsigned int result;
78091
78092   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78093   {
78094     try {
78095       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (Dali::DaliException e) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78107       };
78108     } catch (...) {
78109       {
78110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78111       };
78112     }
78113   }
78114
78115   jresult = result;
78116   return jresult;
78117 }
78118
78119
78120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78121   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78122
78123   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78124   {
78125     try {
78126       delete arg1;
78127     } catch (std::out_of_range& e) {
78128       {
78129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78130       };
78131     } catch (std::exception& e) {
78132       {
78133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78134       };
78135     } catch (Dali::DaliException e) {
78136       {
78137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78138       };
78139     } catch (...) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78142       };
78143     }
78144   }
78145
78146 }
78147
78148
78149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78150   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78151   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78152
78153   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78154   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78155   if (arg1) (arg1)->scale = *arg2;
78156 }
78157
78158
78159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78160   void * jresult ;
78161   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78162   Dali::Toolkit::ClampState2D *result = 0 ;
78163
78164   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78165   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78166   jresult = (void *)result;
78167   return jresult;
78168 }
78169
78170
78171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78172   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78173   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78174
78175   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78176   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78177   if (arg1) (arg1)->position = *arg2;
78178 }
78179
78180
78181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78182   void * jresult ;
78183   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78184   Dali::Toolkit::ClampState2D *result = 0 ;
78185
78186   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78187   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78188   jresult = (void *)result;
78189   return jresult;
78190 }
78191
78192
78193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78194   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78195   Dali::Toolkit::ClampState arg2 ;
78196
78197   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78198   arg2 = (Dali::Toolkit::ClampState)jarg2;
78199   if (arg1) (arg1)->rotation = arg2;
78200 }
78201
78202
78203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78204   int jresult ;
78205   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78206   Dali::Toolkit::ClampState result;
78207
78208   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78209   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78210   jresult = (int)result;
78211   return jresult;
78212 }
78213
78214
78215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78216   void * jresult ;
78217   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78218
78219   {
78220     try {
78221       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78222     } catch (std::out_of_range& e) {
78223       {
78224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78225       };
78226     } catch (std::exception& e) {
78227       {
78228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78229       };
78230     } catch (Dali::DaliException e) {
78231       {
78232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78233       };
78234     } catch (...) {
78235       {
78236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78237       };
78238     }
78239   }
78240
78241   jresult = (void *)result;
78242   return jresult;
78243 }
78244
78245
78246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78247   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78248
78249   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78250   {
78251     try {
78252       delete arg1;
78253     } catch (std::out_of_range& e) {
78254       {
78255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78256       };
78257     } catch (std::exception& e) {
78258       {
78259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78260       };
78261     } catch (Dali::DaliException e) {
78262       {
78263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78264       };
78265     } catch (...) {
78266       {
78267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78268       };
78269     }
78270   }
78271
78272 }
78273
78274
78275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78276   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78277   Dali::Toolkit::SnapType arg2 ;
78278
78279   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78280   arg2 = (Dali::Toolkit::SnapType)jarg2;
78281   if (arg1) (arg1)->type = arg2;
78282 }
78283
78284
78285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78286   int jresult ;
78287   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78288   Dali::Toolkit::SnapType result;
78289
78290   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78291   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78292   jresult = (int)result;
78293   return jresult;
78294 }
78295
78296
78297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78298   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78299   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78300
78301   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78302   arg2 = (Dali::Vector2 *)jarg2;
78303   if (arg1) (arg1)->position = *arg2;
78304 }
78305
78306
78307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78308   void * jresult ;
78309   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78310   Dali::Vector2 *result = 0 ;
78311
78312   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78313   result = (Dali::Vector2 *)& ((arg1)->position);
78314   jresult = (void *)result;
78315   return jresult;
78316 }
78317
78318
78319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78320   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78321   float arg2 ;
78322
78323   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78324   arg2 = (float)jarg2;
78325   if (arg1) (arg1)->duration = arg2;
78326 }
78327
78328
78329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78330   float jresult ;
78331   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78332   float result;
78333
78334   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78335   result = (float) ((arg1)->duration);
78336   jresult = result;
78337   return jresult;
78338 }
78339
78340
78341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78342   void * jresult ;
78343   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78344
78345   {
78346     try {
78347       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78348     } catch (std::out_of_range& e) {
78349       {
78350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78351       };
78352     } catch (std::exception& e) {
78353       {
78354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78355       };
78356     } catch (Dali::DaliException e) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78359       };
78360     } catch (...) {
78361       {
78362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78363       };
78364     }
78365   }
78366
78367   jresult = (void *)result;
78368   return jresult;
78369 }
78370
78371
78372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78373   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78374
78375   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78376   {
78377     try {
78378       delete arg1;
78379     } catch (std::out_of_range& e) {
78380       {
78381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78382       };
78383     } catch (std::exception& e) {
78384       {
78385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78386       };
78387     } catch (Dali::DaliException e) {
78388       {
78389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78390       };
78391     } catch (...) {
78392       {
78393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78394       };
78395     }
78396   }
78397
78398 }
78399
78400
78401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78402   int jresult ;
78403   int result;
78404
78405   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78406   jresult = (int)result;
78407   return jresult;
78408 }
78409
78410
78411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78412   int jresult ;
78413   int result;
78414
78415   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78416   jresult = (int)result;
78417   return jresult;
78418 }
78419
78420
78421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78422   int jresult ;
78423   int result;
78424
78425   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78426   jresult = (int)result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78432   int jresult ;
78433   int result;
78434
78435   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78436   jresult = (int)result;
78437   return jresult;
78438 }
78439
78440
78441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78442   int jresult ;
78443   int result;
78444
78445   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78446   jresult = (int)result;
78447   return jresult;
78448 }
78449
78450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78451   int jresult ;
78452   int result;
78453
78454   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78455   jresult = (int)result;
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78461   int jresult ;
78462   int result;
78463
78464   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78465   jresult = (int)result;
78466   return jresult;
78467 }
78468
78469
78470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78471   int jresult ;
78472   int result;
78473
78474   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78475   jresult = (int)result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78481   int jresult ;
78482   int result;
78483
78484   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78485   jresult = (int)result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78491   int jresult ;
78492   int result;
78493
78494   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78495   jresult = (int)result;
78496   return jresult;
78497 }
78498
78499
78500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78501   int jresult ;
78502   int result;
78503
78504   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78505   jresult = (int)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78511   int jresult ;
78512   int result;
78513
78514   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78515   jresult = (int)result;
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78521   int jresult ;
78522   int result;
78523
78524   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78525   jresult = (int)result;
78526   return jresult;
78527 }
78528
78529
78530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78531   int jresult ;
78532   int result;
78533
78534   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78535   jresult = (int)result;
78536   return jresult;
78537 }
78538
78539
78540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78541   int jresult ;
78542   int result;
78543
78544   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78545   jresult = (int)result;
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78551   int jresult ;
78552   int result;
78553
78554   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78555   jresult = (int)result;
78556   return jresult;
78557 }
78558
78559
78560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78561   int jresult ;
78562   int result;
78563
78564   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78565   jresult = (int)result;
78566   return jresult;
78567 }
78568
78569
78570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78571   int jresult ;
78572   int result;
78573
78574   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78575   jresult = (int)result;
78576   return jresult;
78577 }
78578
78579
78580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78581   int jresult ;
78582   int result;
78583
78584   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78585   jresult = (int)result;
78586   return jresult;
78587 }
78588
78589
78590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78591   int jresult ;
78592   int result;
78593
78594   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78595   jresult = (int)result;
78596   return jresult;
78597 }
78598
78599
78600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78601   int jresult ;
78602   int result;
78603
78604   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78605   jresult = (int)result;
78606   return jresult;
78607 }
78608
78609
78610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78611   int jresult ;
78612   int result;
78613
78614   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78615   jresult = (int)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78621   int jresult ;
78622   int result;
78623
78624   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78625   jresult = (int)result;
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78631   int jresult ;
78632   int result;
78633
78634   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78635   jresult = (int)result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78641   int jresult ;
78642   int result;
78643
78644   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78645   jresult = (int)result;
78646   return jresult;
78647 }
78648
78649
78650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78651   int jresult ;
78652   int result;
78653
78654   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78655   jresult = (int)result;
78656   return jresult;
78657 }
78658
78659
78660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78661   void * jresult ;
78662   Dali::Toolkit::ScrollView::Property *result = 0 ;
78663
78664   {
78665     try {
78666       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78667     } catch (std::out_of_range& e) {
78668       {
78669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78670       };
78671     } catch (std::exception& e) {
78672       {
78673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78674       };
78675     } catch (Dali::DaliException e) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78678       };
78679     } catch (...) {
78680       {
78681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78682       };
78683     }
78684   }
78685
78686   jresult = (void *)result;
78687   return jresult;
78688 }
78689
78690
78691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78692   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78693
78694   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78695   {
78696     try {
78697       delete arg1;
78698     } catch (std::out_of_range& e) {
78699       {
78700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78701       };
78702     } catch (std::exception& e) {
78703       {
78704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78705       };
78706     } catch (Dali::DaliException e) {
78707       {
78708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78709       };
78710     } catch (...) {
78711       {
78712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78713       };
78714     }
78715   }
78716
78717 }
78718
78719
78720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78721   void * jresult ;
78722   Dali::Toolkit::ScrollView *result = 0 ;
78723
78724   {
78725     try {
78726       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78727     } catch (std::out_of_range& e) {
78728       {
78729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (std::exception& e) {
78732       {
78733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78734       };
78735     } catch (Dali::DaliException e) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78738       };
78739     } catch (...) {
78740       {
78741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78742       };
78743     }
78744   }
78745
78746   jresult = (void *)result;
78747   return jresult;
78748 }
78749
78750
78751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78752   void * jresult ;
78753   Dali::Toolkit::ScrollView *arg1 = 0 ;
78754   Dali::Toolkit::ScrollView *result = 0 ;
78755
78756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78757   if (!arg1) {
78758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78759     return 0;
78760   }
78761   {
78762     try {
78763       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78764     } catch (std::out_of_range& e) {
78765       {
78766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78767       };
78768     } catch (std::exception& e) {
78769       {
78770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78771       };
78772     } catch (Dali::DaliException e) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78775       };
78776     } catch (...) {
78777       {
78778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78779       };
78780     }
78781   }
78782
78783   jresult = (void *)result;
78784   return jresult;
78785 }
78786
78787
78788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78789   void * jresult ;
78790   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78791   Dali::Toolkit::ScrollView *arg2 = 0 ;
78792   Dali::Toolkit::ScrollView *result = 0 ;
78793
78794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78795   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78796   if (!arg2) {
78797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78798     return 0;
78799   }
78800   {
78801     try {
78802       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78803     } catch (std::out_of_range& e) {
78804       {
78805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (std::exception& e) {
78808       {
78809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78810       };
78811     } catch (Dali::DaliException e) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78814       };
78815     } catch (...) {
78816       {
78817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78818       };
78819     }
78820   }
78821
78822   jresult = (void *)result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78829
78830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78831   {
78832     try {
78833       delete arg1;
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78841       };
78842     } catch (Dali::DaliException e) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78845       };
78846     } catch (...) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78849       };
78850     }
78851   }
78852
78853 }
78854
78855
78856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78857   void * jresult ;
78858   Dali::Toolkit::ScrollView result;
78859
78860   {
78861     try {
78862       result = Dali::Toolkit::ScrollView::New();
78863     } catch (std::out_of_range& e) {
78864       {
78865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78866       };
78867     } catch (std::exception& e) {
78868       {
78869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (Dali::DaliException e) {
78872       {
78873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78874       };
78875     } catch (...) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78878       };
78879     }
78880   }
78881
78882   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78883   return jresult;
78884 }
78885
78886
78887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78888   void * jresult ;
78889   Dali::BaseHandle arg1 ;
78890   Dali::BaseHandle *argp1 ;
78891   Dali::Toolkit::ScrollView result;
78892
78893   argp1 = (Dali::BaseHandle *)jarg1;
78894   if (!argp1) {
78895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78896     return 0;
78897   }
78898   arg1 = *argp1;
78899   {
78900     try {
78901       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78902     } catch (std::out_of_range& e) {
78903       {
78904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78905       };
78906     } catch (std::exception& e) {
78907       {
78908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78909       };
78910     } catch (Dali::DaliException e) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78913       };
78914     } catch (...) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78917       };
78918     }
78919   }
78920
78921   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78922   return jresult;
78923 }
78924
78925
78926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
78927   void * jresult ;
78928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78929   Dali::AlphaFunction result;
78930
78931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78932   {
78933     try {
78934       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
78935     } catch (std::out_of_range& e) {
78936       {
78937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (std::exception& e) {
78940       {
78941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (Dali::DaliException e) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78946       };
78947     } catch (...) {
78948       {
78949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78950       };
78951     }
78952   }
78953
78954   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78955   return jresult;
78956 }
78957
78958
78959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
78960   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78961   Dali::AlphaFunction arg2 ;
78962   Dali::AlphaFunction *argp2 ;
78963
78964   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78965   argp2 = (Dali::AlphaFunction *)jarg2;
78966   if (!argp2) {
78967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78968     return ;
78969   }
78970   arg2 = *argp2;
78971   {
78972     try {
78973       (arg1)->SetScrollSnapAlphaFunction(arg2);
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78989       };
78990     }
78991   }
78992
78993 }
78994
78995
78996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
78997   void * jresult ;
78998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78999   Dali::AlphaFunction result;
79000
79001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79002   {
79003     try {
79004       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79012       };
79013     } catch (Dali::DaliException e) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79016       };
79017     } catch (...) {
79018       {
79019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79020       };
79021     }
79022   }
79023
79024   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79025   return jresult;
79026 }
79027
79028
79029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79031   Dali::AlphaFunction arg2 ;
79032   Dali::AlphaFunction *argp2 ;
79033
79034   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79035   argp2 = (Dali::AlphaFunction *)jarg2;
79036   if (!argp2) {
79037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79038     return ;
79039   }
79040   arg2 = *argp2;
79041   {
79042     try {
79043       (arg1)->SetScrollFlickAlphaFunction(arg2);
79044     } catch (std::out_of_range& e) {
79045       {
79046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79047       };
79048     } catch (std::exception& e) {
79049       {
79050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79051       };
79052     } catch (Dali::DaliException e) {
79053       {
79054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79055       };
79056     } catch (...) {
79057       {
79058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79059       };
79060     }
79061   }
79062
79063 }
79064
79065
79066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79067   float jresult ;
79068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79069   float result;
79070
79071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79072   {
79073     try {
79074       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79075     } catch (std::out_of_range& e) {
79076       {
79077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (std::exception& e) {
79080       {
79081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (Dali::DaliException e) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79090       };
79091     }
79092   }
79093
79094   jresult = result;
79095   return jresult;
79096 }
79097
79098
79099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79100   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79101   float arg2 ;
79102
79103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79104   arg2 = (float)jarg2;
79105   {
79106     try {
79107       (arg1)->SetScrollSnapDuration(arg2);
79108     } catch (std::out_of_range& e) {
79109       {
79110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79111       };
79112     } catch (std::exception& e) {
79113       {
79114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79115       };
79116     } catch (Dali::DaliException e) {
79117       {
79118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79119       };
79120     } catch (...) {
79121       {
79122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79123       };
79124     }
79125   }
79126
79127 }
79128
79129
79130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79131   float jresult ;
79132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79133   float result;
79134
79135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79136   {
79137     try {
79138       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79139     } catch (std::out_of_range& e) {
79140       {
79141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79142       };
79143     } catch (std::exception& e) {
79144       {
79145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79146       };
79147     } catch (Dali::DaliException e) {
79148       {
79149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79150       };
79151     } catch (...) {
79152       {
79153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79154       };
79155     }
79156   }
79157
79158   jresult = result;
79159   return jresult;
79160 }
79161
79162
79163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79165   float arg2 ;
79166
79167   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79168   arg2 = (float)jarg2;
79169   {
79170     try {
79171       (arg1)->SetScrollFlickDuration(arg2);
79172     } catch (std::out_of_range& e) {
79173       {
79174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79175       };
79176     } catch (std::exception& e) {
79177       {
79178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79179       };
79180     } catch (Dali::DaliException e) {
79181       {
79182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79183       };
79184     } catch (...) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79187       };
79188     }
79189   }
79190
79191 }
79192
79193
79194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79195   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79196   Dali::Toolkit::RulerPtr arg2 ;
79197   Dali::Toolkit::RulerPtr *argp2 ;
79198
79199   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79200   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79201   if (!argp2) {
79202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79203     return ;
79204   }
79205   arg2 = *argp2;
79206   {
79207     try {
79208       (arg1)->SetRulerX(arg2);
79209     } catch (std::out_of_range& e) {
79210       {
79211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79212       };
79213     } catch (std::exception& e) {
79214       {
79215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79216       };
79217     } catch (Dali::DaliException e) {
79218       {
79219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79220       };
79221     } catch (...) {
79222       {
79223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79224       };
79225     }
79226   }
79227
79228 }
79229
79230
79231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79233   Dali::Toolkit::RulerPtr arg2 ;
79234   Dali::Toolkit::RulerPtr *argp2 ;
79235
79236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79237   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79238   if (!argp2) {
79239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79240     return ;
79241   }
79242   arg2 = *argp2;
79243   {
79244     try {
79245       (arg1)->SetRulerY(arg2);
79246     } catch (std::out_of_range& e) {
79247       {
79248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79249       };
79250     } catch (std::exception& e) {
79251       {
79252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79253       };
79254     } catch (Dali::DaliException e) {
79255       {
79256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79257       };
79258     } catch (...) {
79259       {
79260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79261       };
79262     }
79263   }
79264
79265 }
79266
79267
79268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79270   bool arg2 ;
79271
79272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79273   arg2 = jarg2 ? true : false;
79274   {
79275     try {
79276       (arg1)->SetScrollSensitive(arg2);
79277     } catch (std::out_of_range& e) {
79278       {
79279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79280       };
79281     } catch (std::exception& e) {
79282       {
79283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79284       };
79285     } catch (Dali::DaliException e) {
79286       {
79287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79288       };
79289     } catch (...) {
79290       {
79291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79292       };
79293     }
79294   }
79295
79296 }
79297
79298
79299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79300   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79301   float arg2 ;
79302   float arg3 ;
79303
79304   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79305   arg2 = (float)jarg2;
79306   arg3 = (float)jarg3;
79307   {
79308     try {
79309       (arg1)->SetMaxOvershoot(arg2,arg3);
79310     } catch (std::out_of_range& e) {
79311       {
79312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79313       };
79314     } catch (std::exception& e) {
79315       {
79316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79317       };
79318     } catch (Dali::DaliException e) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79321       };
79322     } catch (...) {
79323       {
79324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79325       };
79326     }
79327   }
79328
79329 }
79330
79331
79332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79334   Dali::AlphaFunction arg2 ;
79335   Dali::AlphaFunction *argp2 ;
79336
79337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79338   argp2 = (Dali::AlphaFunction *)jarg2;
79339   if (!argp2) {
79340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79341     return ;
79342   }
79343   arg2 = *argp2;
79344   {
79345     try {
79346       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79347     } catch (std::out_of_range& e) {
79348       {
79349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79350       };
79351     } catch (std::exception& e) {
79352       {
79353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79354       };
79355     } catch (Dali::DaliException e) {
79356       {
79357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79358       };
79359     } catch (...) {
79360       {
79361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79362       };
79363     }
79364   }
79365
79366 }
79367
79368
79369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79370   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79371   float arg2 ;
79372
79373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79374   arg2 = (float)jarg2;
79375   {
79376     try {
79377       (arg1)->SetSnapOvershootDuration(arg2);
79378     } catch (std::out_of_range& e) {
79379       {
79380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79381       };
79382     } catch (std::exception& e) {
79383       {
79384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79385       };
79386     } catch (Dali::DaliException e) {
79387       {
79388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79389       };
79390     } catch (...) {
79391       {
79392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79393       };
79394     }
79395   }
79396
79397 }
79398
79399
79400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79402   bool arg2 ;
79403
79404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79405   arg2 = jarg2 ? true : false;
79406   {
79407     try {
79408       (arg1)->SetActorAutoSnap(arg2);
79409     } catch (std::out_of_range& e) {
79410       {
79411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79412       };
79413     } catch (std::exception& e) {
79414       {
79415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79416       };
79417     } catch (Dali::DaliException e) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79420       };
79421     } catch (...) {
79422       {
79423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79424       };
79425     }
79426   }
79427
79428 }
79429
79430
79431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79432   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79433   bool arg2 ;
79434
79435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79436   arg2 = jarg2 ? true : false;
79437   {
79438     try {
79439       (arg1)->SetWrapMode(arg2);
79440     } catch (std::out_of_range& e) {
79441       {
79442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79443       };
79444     } catch (std::exception& e) {
79445       {
79446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79447       };
79448     } catch (Dali::DaliException e) {
79449       {
79450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79451       };
79452     } catch (...) {
79453       {
79454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79455       };
79456     }
79457   }
79458
79459 }
79460
79461
79462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79463   int jresult ;
79464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79465   int result;
79466
79467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79468   {
79469     try {
79470       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79471     } catch (std::out_of_range& e) {
79472       {
79473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79474       };
79475     } catch (std::exception& e) {
79476       {
79477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79478       };
79479     } catch (Dali::DaliException e) {
79480       {
79481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79482       };
79483     } catch (...) {
79484       {
79485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79486       };
79487     }
79488   }
79489
79490   jresult = result;
79491   return jresult;
79492 }
79493
79494
79495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79496   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79497   int arg2 ;
79498
79499   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79500   arg2 = (int)jarg2;
79501   {
79502     try {
79503       (arg1)->SetScrollUpdateDistance(arg2);
79504     } catch (std::out_of_range& e) {
79505       {
79506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79507       };
79508     } catch (std::exception& e) {
79509       {
79510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79511       };
79512     } catch (Dali::DaliException e) {
79513       {
79514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79515       };
79516     } catch (...) {
79517       {
79518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79519       };
79520     }
79521   }
79522
79523 }
79524
79525
79526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79527   unsigned int jresult ;
79528   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79529   bool result;
79530
79531   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79532   {
79533     try {
79534       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79535     } catch (std::out_of_range& e) {
79536       {
79537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (std::exception& e) {
79540       {
79541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (Dali::DaliException e) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79546       };
79547     } catch (...) {
79548       {
79549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79550       };
79551     }
79552   }
79553
79554   jresult = result;
79555   return jresult;
79556 }
79557
79558
79559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79560   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79561   bool arg2 ;
79562
79563   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79564   arg2 = jarg2 ? true : false;
79565   {
79566     try {
79567       (arg1)->SetAxisAutoLock(arg2);
79568     } catch (std::out_of_range& e) {
79569       {
79570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79571       };
79572     } catch (std::exception& e) {
79573       {
79574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79575       };
79576     } catch (Dali::DaliException e) {
79577       {
79578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79579       };
79580     } catch (...) {
79581       {
79582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79583       };
79584     }
79585   }
79586
79587 }
79588
79589
79590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79591   float jresult ;
79592   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79593   float result;
79594
79595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79596   {
79597     try {
79598       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79599     } catch (std::out_of_range& e) {
79600       {
79601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79602       };
79603     } catch (std::exception& e) {
79604       {
79605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79606       };
79607     } catch (Dali::DaliException e) {
79608       {
79609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79610       };
79611     } catch (...) {
79612       {
79613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79614       };
79615     }
79616   }
79617
79618   jresult = result;
79619   return jresult;
79620 }
79621
79622
79623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79625   float arg2 ;
79626
79627   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79628   arg2 = (float)jarg2;
79629   {
79630     try {
79631       (arg1)->SetAxisAutoLockGradient(arg2);
79632     } catch (std::out_of_range& e) {
79633       {
79634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79635       };
79636     } catch (std::exception& e) {
79637       {
79638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79639       };
79640     } catch (Dali::DaliException e) {
79641       {
79642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79643       };
79644     } catch (...) {
79645       {
79646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79647       };
79648     }
79649   }
79650
79651 }
79652
79653
79654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79655   float jresult ;
79656   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79657   float result;
79658
79659   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79660   {
79661     try {
79662       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79663     } catch (std::out_of_range& e) {
79664       {
79665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79666       };
79667     } catch (std::exception& e) {
79668       {
79669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79670       };
79671     } catch (Dali::DaliException e) {
79672       {
79673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79674       };
79675     } catch (...) {
79676       {
79677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79678       };
79679     }
79680   }
79681
79682   jresult = result;
79683   return jresult;
79684 }
79685
79686
79687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79689   float arg2 ;
79690
79691   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79692   arg2 = (float)jarg2;
79693   {
79694     try {
79695       (arg1)->SetFrictionCoefficient(arg2);
79696     } catch (std::out_of_range& e) {
79697       {
79698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79699       };
79700     } catch (std::exception& e) {
79701       {
79702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79703       };
79704     } catch (Dali::DaliException e) {
79705       {
79706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79707       };
79708     } catch (...) {
79709       {
79710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79711       };
79712     }
79713   }
79714
79715 }
79716
79717
79718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79719   float jresult ;
79720   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79721   float result;
79722
79723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79724   {
79725     try {
79726       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79727     } catch (std::out_of_range& e) {
79728       {
79729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79730       };
79731     } catch (std::exception& e) {
79732       {
79733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79734       };
79735     } catch (Dali::DaliException e) {
79736       {
79737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79738       };
79739     } catch (...) {
79740       {
79741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79742       };
79743     }
79744   }
79745
79746   jresult = result;
79747   return jresult;
79748 }
79749
79750
79751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79753   float arg2 ;
79754
79755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79756   arg2 = (float)jarg2;
79757   {
79758     try {
79759       (arg1)->SetFlickSpeedCoefficient(arg2);
79760     } catch (std::out_of_range& e) {
79761       {
79762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79763       };
79764     } catch (std::exception& e) {
79765       {
79766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79767       };
79768     } catch (Dali::DaliException e) {
79769       {
79770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79771       };
79772     } catch (...) {
79773       {
79774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79775       };
79776     }
79777   }
79778
79779 }
79780
79781
79782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79783   void * jresult ;
79784   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79785   Dali::Vector2 result;
79786
79787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79788   {
79789     try {
79790       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79791     } catch (std::out_of_range& e) {
79792       {
79793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (std::exception& e) {
79796       {
79797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79798       };
79799     } catch (Dali::DaliException e) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79802       };
79803     } catch (...) {
79804       {
79805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79806       };
79807     }
79808   }
79809
79810   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79811   return jresult;
79812 }
79813
79814
79815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79817   Dali::Vector2 *arg2 = 0 ;
79818
79819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79820   arg2 = (Dali::Vector2 *)jarg2;
79821   if (!arg2) {
79822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79823     return ;
79824   }
79825   {
79826     try {
79827       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79828     } catch (std::out_of_range& e) {
79829       {
79830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79831       };
79832     } catch (std::exception& e) {
79833       {
79834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79835       };
79836     } catch (Dali::DaliException e) {
79837       {
79838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79839       };
79840     } catch (...) {
79841       {
79842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79843       };
79844     }
79845   }
79846
79847 }
79848
79849
79850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79851   float jresult ;
79852   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79853   float result;
79854
79855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79856   {
79857     try {
79858       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79859     } catch (std::out_of_range& e) {
79860       {
79861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79862       };
79863     } catch (std::exception& e) {
79864       {
79865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79866       };
79867     } catch (Dali::DaliException e) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79870       };
79871     } catch (...) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79874       };
79875     }
79876   }
79877
79878   jresult = result;
79879   return jresult;
79880 }
79881
79882
79883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79885   float arg2 ;
79886
79887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79888   arg2 = (float)jarg2;
79889   {
79890     try {
79891       (arg1)->SetMinimumSpeedForFlick(arg2);
79892     } catch (std::out_of_range& e) {
79893       {
79894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79895       };
79896     } catch (std::exception& e) {
79897       {
79898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79899       };
79900     } catch (Dali::DaliException e) {
79901       {
79902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79903       };
79904     } catch (...) {
79905       {
79906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79907       };
79908     }
79909   }
79910
79911 }
79912
79913
79914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79915   float jresult ;
79916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79917   float result;
79918
79919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79920   {
79921     try {
79922       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
79923     } catch (std::out_of_range& e) {
79924       {
79925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79926       };
79927     } catch (std::exception& e) {
79928       {
79929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79930       };
79931     } catch (Dali::DaliException e) {
79932       {
79933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79934       };
79935     } catch (...) {
79936       {
79937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79938       };
79939     }
79940   }
79941
79942   jresult = result;
79943   return jresult;
79944 }
79945
79946
79947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
79948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79949   float arg2 ;
79950
79951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79952   arg2 = (float)jarg2;
79953   {
79954     try {
79955       (arg1)->SetMaxFlickSpeed(arg2);
79956     } catch (std::out_of_range& e) {
79957       {
79958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79959       };
79960     } catch (std::exception& e) {
79961       {
79962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79963       };
79964     } catch (Dali::DaliException e) {
79965       {
79966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79967       };
79968     } catch (...) {
79969       {
79970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79971       };
79972     }
79973   }
79974
79975 }
79976
79977
79978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
79979   void * jresult ;
79980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79981   Dali::Vector2 result;
79982
79983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79984   {
79985     try {
79986       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
79987     } catch (std::out_of_range& e) {
79988       {
79989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (std::exception& e) {
79992       {
79993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79994       };
79995     } catch (Dali::DaliException e) {
79996       {
79997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79998       };
79999     } catch (...) {
80000       {
80001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80002       };
80003     }
80004   }
80005
80006   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80007   return jresult;
80008 }
80009
80010
80011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80012   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80013   Dali::Vector2 arg2 ;
80014   Dali::Vector2 *argp2 ;
80015
80016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80017   argp2 = (Dali::Vector2 *)jarg2;
80018   if (!argp2) {
80019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80020     return ;
80021   }
80022   arg2 = *argp2;
80023   {
80024     try {
80025       (arg1)->SetWheelScrollDistanceStep(arg2);
80026     } catch (std::out_of_range& e) {
80027       {
80028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80029       };
80030     } catch (std::exception& e) {
80031       {
80032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80033       };
80034     } catch (Dali::DaliException e) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80037       };
80038     } catch (...) {
80039       {
80040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80041       };
80042     }
80043   }
80044
80045 }
80046
80047
80048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80049   void * jresult ;
80050   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80051   Dali::Vector2 result;
80052
80053   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80054   {
80055     try {
80056       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80064       };
80065     } catch (Dali::DaliException e) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80072       };
80073     }
80074   }
80075
80076   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80077   return jresult;
80078 }
80079
80080
80081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80082   unsigned int jresult ;
80083   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80084   unsigned int result;
80085
80086   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80087   {
80088     try {
80089       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80090     } catch (std::out_of_range& e) {
80091       {
80092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80093       };
80094     } catch (std::exception& e) {
80095       {
80096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80097       };
80098     } catch (Dali::DaliException e) {
80099       {
80100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80101       };
80102     } catch (...) {
80103       {
80104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80105       };
80106     }
80107   }
80108
80109   jresult = result;
80110   return jresult;
80111 }
80112
80113
80114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80116   Dali::Vector2 *arg2 = 0 ;
80117
80118   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80119   arg2 = (Dali::Vector2 *)jarg2;
80120   if (!arg2) {
80121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80122     return ;
80123   }
80124   {
80125     try {
80126       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80127     } catch (std::out_of_range& e) {
80128       {
80129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80130       };
80131     } catch (std::exception& e) {
80132       {
80133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (Dali::DaliException e) {
80136       {
80137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80138       };
80139     } catch (...) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80142       };
80143     }
80144   }
80145
80146 }
80147
80148
80149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80151   Dali::Vector2 *arg2 = 0 ;
80152   float arg3 ;
80153
80154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80155   arg2 = (Dali::Vector2 *)jarg2;
80156   if (!arg2) {
80157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80158     return ;
80159   }
80160   arg3 = (float)jarg3;
80161   {
80162     try {
80163       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80164     } catch (std::out_of_range& e) {
80165       {
80166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80167       };
80168     } catch (std::exception& e) {
80169       {
80170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80171       };
80172     } catch (Dali::DaliException e) {
80173       {
80174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80175       };
80176     } catch (...) {
80177       {
80178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80179       };
80180     }
80181   }
80182
80183 }
80184
80185
80186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80187   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80188   Dali::Vector2 *arg2 = 0 ;
80189   float arg3 ;
80190   Dali::AlphaFunction arg4 ;
80191   Dali::AlphaFunction *argp4 ;
80192
80193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80194   arg2 = (Dali::Vector2 *)jarg2;
80195   if (!arg2) {
80196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80197     return ;
80198   }
80199   arg3 = (float)jarg3;
80200   argp4 = (Dali::AlphaFunction *)jarg4;
80201   if (!argp4) {
80202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80203     return ;
80204   }
80205   arg4 = *argp4;
80206   {
80207     try {
80208       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (Dali::DaliException e) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80220       };
80221     } catch (...) {
80222       {
80223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80224       };
80225     }
80226   }
80227
80228 }
80229
80230
80231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80232   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80233   Dali::Vector2 *arg2 = 0 ;
80234   float arg3 ;
80235   Dali::Toolkit::DirectionBias arg4 ;
80236   Dali::Toolkit::DirectionBias arg5 ;
80237
80238   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80239   arg2 = (Dali::Vector2 *)jarg2;
80240   if (!arg2) {
80241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80242     return ;
80243   }
80244   arg3 = (float)jarg3;
80245   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80246   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80247   {
80248     try {
80249       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80250     } catch (std::out_of_range& e) {
80251       {
80252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80253       };
80254     } catch (std::exception& e) {
80255       {
80256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80257       };
80258     } catch (Dali::DaliException e) {
80259       {
80260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80261       };
80262     } catch (...) {
80263       {
80264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80265       };
80266     }
80267   }
80268
80269 }
80270
80271
80272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80274   Dali::Vector2 *arg2 = 0 ;
80275   float arg3 ;
80276   Dali::AlphaFunction arg4 ;
80277   Dali::Toolkit::DirectionBias arg5 ;
80278   Dali::Toolkit::DirectionBias arg6 ;
80279   Dali::AlphaFunction *argp4 ;
80280
80281   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80282   arg2 = (Dali::Vector2 *)jarg2;
80283   if (!arg2) {
80284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80285     return ;
80286   }
80287   arg3 = (float)jarg3;
80288   argp4 = (Dali::AlphaFunction *)jarg4;
80289   if (!argp4) {
80290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80291     return ;
80292   }
80293   arg4 = *argp4;
80294   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80295   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80296   {
80297     try {
80298       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80299     } catch (std::out_of_range& e) {
80300       {
80301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80302       };
80303     } catch (std::exception& e) {
80304       {
80305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80306       };
80307     } catch (Dali::DaliException e) {
80308       {
80309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80310       };
80311     } catch (...) {
80312       {
80313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80314       };
80315     }
80316   }
80317
80318 }
80319
80320
80321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80323   unsigned int arg2 ;
80324
80325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80326   arg2 = (unsigned int)jarg2;
80327   {
80328     try {
80329       (arg1)->ScrollTo(arg2);
80330     } catch (std::out_of_range& e) {
80331       {
80332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80333       };
80334     } catch (std::exception& e) {
80335       {
80336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80337       };
80338     } catch (Dali::DaliException e) {
80339       {
80340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80341       };
80342     } catch (...) {
80343       {
80344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80345       };
80346     }
80347   }
80348
80349 }
80350
80351
80352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80354   unsigned int arg2 ;
80355   float arg3 ;
80356
80357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80358   arg2 = (unsigned int)jarg2;
80359   arg3 = (float)jarg3;
80360   {
80361     try {
80362       (arg1)->ScrollTo(arg2,arg3);
80363     } catch (std::out_of_range& e) {
80364       {
80365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80366       };
80367     } catch (std::exception& e) {
80368       {
80369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80370       };
80371     } catch (Dali::DaliException e) {
80372       {
80373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80374       };
80375     } catch (...) {
80376       {
80377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80378       };
80379     }
80380   }
80381
80382 }
80383
80384
80385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80387   unsigned int arg2 ;
80388   float arg3 ;
80389   Dali::Toolkit::DirectionBias arg4 ;
80390
80391   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80392   arg2 = (unsigned int)jarg2;
80393   arg3 = (float)jarg3;
80394   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80395   {
80396     try {
80397       (arg1)->ScrollTo(arg2,arg3,arg4);
80398     } catch (std::out_of_range& e) {
80399       {
80400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80401       };
80402     } catch (std::exception& e) {
80403       {
80404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80405       };
80406     } catch (Dali::DaliException e) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80409       };
80410     } catch (...) {
80411       {
80412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80413       };
80414     }
80415   }
80416
80417 }
80418
80419
80420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80421   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80422   Dali::Actor *arg2 = 0 ;
80423
80424   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80425   arg2 = (Dali::Actor *)jarg2;
80426   if (!arg2) {
80427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80428     return ;
80429   }
80430   {
80431     try {
80432       (arg1)->ScrollTo(*arg2);
80433     } catch (std::out_of_range& e) {
80434       {
80435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80436       };
80437     } catch (std::exception& e) {
80438       {
80439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80440       };
80441     } catch (Dali::DaliException e) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80444       };
80445     } catch (...) {
80446       {
80447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80448       };
80449     }
80450   }
80451
80452 }
80453
80454
80455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80456   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80457   Dali::Actor *arg2 = 0 ;
80458   float arg3 ;
80459
80460   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80461   arg2 = (Dali::Actor *)jarg2;
80462   if (!arg2) {
80463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80464     return ;
80465   }
80466   arg3 = (float)jarg3;
80467   {
80468     try {
80469       (arg1)->ScrollTo(*arg2,arg3);
80470     } catch (std::out_of_range& e) {
80471       {
80472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80473       };
80474     } catch (std::exception& e) {
80475       {
80476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80477       };
80478     } catch (Dali::DaliException e) {
80479       {
80480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80481       };
80482     } catch (...) {
80483       {
80484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80485       };
80486     }
80487   }
80488
80489 }
80490
80491
80492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80493   unsigned int jresult ;
80494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80495   bool result;
80496
80497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80498   {
80499     try {
80500       result = (bool)(arg1)->ScrollToSnapPoint();
80501     } catch (std::out_of_range& e) {
80502       {
80503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (std::exception& e) {
80506       {
80507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80508       };
80509     } catch (Dali::DaliException e) {
80510       {
80511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80512       };
80513     } catch (...) {
80514       {
80515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80516       };
80517     }
80518   }
80519
80520   jresult = result;
80521   return jresult;
80522 }
80523
80524
80525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80527   Dali::Constraint arg2 ;
80528   Dali::Constraint *argp2 ;
80529
80530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80531   argp2 = (Dali::Constraint *)jarg2;
80532   if (!argp2) {
80533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80534     return ;
80535   }
80536   arg2 = *argp2;
80537   {
80538     try {
80539       (arg1)->ApplyConstraintToChildren(arg2);
80540     } catch (std::out_of_range& e) {
80541       {
80542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80543       };
80544     } catch (std::exception& e) {
80545       {
80546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80547       };
80548     } catch (Dali::DaliException e) {
80549       {
80550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80551       };
80552     } catch (...) {
80553       {
80554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80555       };
80556     }
80557   }
80558
80559 }
80560
80561
80562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80564
80565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80566   {
80567     try {
80568       (arg1)->RemoveConstraintsFromChildren();
80569     } catch (std::out_of_range& e) {
80570       {
80571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80572       };
80573     } catch (std::exception& e) {
80574       {
80575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80576       };
80577     } catch (Dali::DaliException e) {
80578       {
80579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80580       };
80581     } catch (...) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80584       };
80585     }
80586   }
80587
80588 }
80589
80590
80591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80592   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80593   Dali::Toolkit::ScrollViewEffect arg2 ;
80594   Dali::Toolkit::ScrollViewEffect *argp2 ;
80595
80596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80597   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80598   if (!argp2) {
80599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80600     return ;
80601   }
80602   arg2 = *argp2;
80603   {
80604     try {
80605       (arg1)->ApplyEffect(arg2);
80606     } catch (std::out_of_range& e) {
80607       {
80608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80609       };
80610     } catch (std::exception& e) {
80611       {
80612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80613       };
80614     } catch (Dali::DaliException e) {
80615       {
80616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80617       };
80618     } catch (...) {
80619       {
80620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80621       };
80622     }
80623   }
80624
80625 }
80626
80627
80628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80630   Dali::Toolkit::ScrollViewEffect arg2 ;
80631   Dali::Toolkit::ScrollViewEffect *argp2 ;
80632
80633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80634   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80635   if (!argp2) {
80636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80637     return ;
80638   }
80639   arg2 = *argp2;
80640   {
80641     try {
80642       (arg1)->RemoveEffect(arg2);
80643     } catch (std::out_of_range& e) {
80644       {
80645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80646       };
80647     } catch (std::exception& e) {
80648       {
80649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80650       };
80651     } catch (Dali::DaliException e) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80654       };
80655     } catch (...) {
80656       {
80657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80658       };
80659     }
80660   }
80661
80662 }
80663
80664
80665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80667
80668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80669   {
80670     try {
80671       (arg1)->RemoveAllEffects();
80672     } catch (std::out_of_range& e) {
80673       {
80674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80675       };
80676     } catch (std::exception& e) {
80677       {
80678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80679       };
80680     } catch (Dali::DaliException e) {
80681       {
80682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80683       };
80684     } catch (...) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80687       };
80688     }
80689   }
80690
80691 }
80692
80693
80694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80695   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80696   Dali::Actor arg2 ;
80697   Dali::Actor *argp2 ;
80698
80699   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80700   argp2 = (Dali::Actor *)jarg2;
80701   if (!argp2) {
80702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80703     return ;
80704   }
80705   arg2 = *argp2;
80706   {
80707     try {
80708       (arg1)->BindActor(arg2);
80709     } catch (std::out_of_range& e) {
80710       {
80711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80712       };
80713     } catch (std::exception& e) {
80714       {
80715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80716       };
80717     } catch (Dali::DaliException e) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80720       };
80721     } catch (...) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80724       };
80725     }
80726   }
80727
80728 }
80729
80730
80731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80732   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80733   Dali::Actor arg2 ;
80734   Dali::Actor *argp2 ;
80735
80736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80737   argp2 = (Dali::Actor *)jarg2;
80738   if (!argp2) {
80739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80740     return ;
80741   }
80742   arg2 = *argp2;
80743   {
80744     try {
80745       (arg1)->UnbindActor(arg2);
80746     } catch (std::out_of_range& e) {
80747       {
80748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80749       };
80750     } catch (std::exception& e) {
80751       {
80752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80753       };
80754     } catch (Dali::DaliException e) {
80755       {
80756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80757       };
80758     } catch (...) {
80759       {
80760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80761       };
80762     }
80763   }
80764
80765 }
80766
80767
80768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80770   Dali::Radian arg2 ;
80771   Dali::Radian arg3 ;
80772   Dali::Radian *argp2 ;
80773   Dali::Radian *argp3 ;
80774
80775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80776   argp2 = (Dali::Radian *)jarg2;
80777   if (!argp2) {
80778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80779     return ;
80780   }
80781   arg2 = *argp2;
80782   argp3 = (Dali::Radian *)jarg3;
80783   if (!argp3) {
80784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80785     return ;
80786   }
80787   arg3 = *argp3;
80788   {
80789     try {
80790       (arg1)->SetScrollingDirection(arg2,arg3);
80791     } catch (std::out_of_range& e) {
80792       {
80793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80794       };
80795     } catch (std::exception& e) {
80796       {
80797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80798       };
80799     } catch (Dali::DaliException e) {
80800       {
80801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80802       };
80803     } catch (...) {
80804       {
80805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80806       };
80807     }
80808   }
80809
80810 }
80811
80812
80813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80815   Dali::Radian arg2 ;
80816   Dali::Radian *argp2 ;
80817
80818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80819   argp2 = (Dali::Radian *)jarg2;
80820   if (!argp2) {
80821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80822     return ;
80823   }
80824   arg2 = *argp2;
80825   {
80826     try {
80827       (arg1)->SetScrollingDirection(arg2);
80828     } catch (std::out_of_range& e) {
80829       {
80830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80831       };
80832     } catch (std::exception& e) {
80833       {
80834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80835       };
80836     } catch (Dali::DaliException e) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80839       };
80840     } catch (...) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80843       };
80844     }
80845   }
80846
80847 }
80848
80849
80850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80852   Dali::Radian arg2 ;
80853   Dali::Radian *argp2 ;
80854
80855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80856   argp2 = (Dali::Radian *)jarg2;
80857   if (!argp2) {
80858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80859     return ;
80860   }
80861   arg2 = *argp2;
80862   {
80863     try {
80864       (arg1)->RemoveScrollingDirection(arg2);
80865     } catch (std::out_of_range& e) {
80866       {
80867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80868       };
80869     } catch (std::exception& e) {
80870       {
80871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80872       };
80873     } catch (Dali::DaliException e) {
80874       {
80875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80876       };
80877     } catch (...) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80880       };
80881     }
80882   }
80883
80884 }
80885
80886
80887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80888   void * jresult ;
80889   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80890   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80891
80892   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80893   {
80894     try {
80895       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80896     } catch (std::out_of_range& e) {
80897       {
80898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80899       };
80900     } catch (std::exception& e) {
80901       {
80902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80903       };
80904     } catch (Dali::DaliException e) {
80905       {
80906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80907       };
80908     } catch (...) {
80909       {
80910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80911       };
80912     }
80913   }
80914
80915   jresult = (void *)result;
80916   return jresult;
80917 }
80918
80919
80920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80921   int jresult ;
80922   int result;
80923
80924   result = (int)Dali::Toolkit::TableView::Property::ROWS;
80925   jresult = (int)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
80931   int jresult ;
80932   int result;
80933
80934   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
80935   jresult = (int)result;
80936   return jresult;
80937 }
80938
80939
80940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
80941   int jresult ;
80942   int result;
80943
80944   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
80945   jresult = (int)result;
80946   return jresult;
80947 }
80948
80949
80950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
80951   int jresult ;
80952   int result;
80953
80954   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
80955   jresult = (int)result;
80956   return jresult;
80957 }
80958
80959
80960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
80961   int jresult ;
80962   int result;
80963
80964   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
80965   jresult = (int)result;
80966   return jresult;
80967 }
80968
80969
80970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
80971   void * jresult ;
80972   Dali::Toolkit::TableView::Property *result = 0 ;
80973
80974   {
80975     try {
80976       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
80977     } catch (std::out_of_range& e) {
80978       {
80979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (std::exception& e) {
80982       {
80983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80984       };
80985     } catch (Dali::DaliException e) {
80986       {
80987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80988       };
80989     } catch (...) {
80990       {
80991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80992       };
80993     }
80994   }
80995
80996   jresult = (void *)result;
80997   return jresult;
80998 }
80999
81000
81001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81002   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81003
81004   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81005   {
81006     try {
81007       delete arg1;
81008     } catch (std::out_of_range& e) {
81009       {
81010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81011       };
81012     } catch (std::exception& e) {
81013       {
81014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81015       };
81016     } catch (Dali::DaliException e) {
81017       {
81018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81019       };
81020     } catch (...) {
81021       {
81022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81023       };
81024     }
81025   }
81026
81027 }
81028
81029
81030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81031   int jresult ;
81032   int result;
81033
81034   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81035   jresult = (int)result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81041   int jresult ;
81042   int result;
81043
81044   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81045   jresult = (int)result;
81046   return jresult;
81047 }
81048
81049
81050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81051   int jresult ;
81052   int result;
81053
81054   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81055   jresult = (int)result;
81056   return jresult;
81057 }
81058
81059
81060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81061   int jresult ;
81062   int result;
81063
81064   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81065   jresult = (int)result;
81066   return jresult;
81067 }
81068
81069
81070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81071   int jresult ;
81072   int result;
81073
81074   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81075   jresult = (int)result;
81076   return jresult;
81077 }
81078
81079
81080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81081   void * jresult ;
81082   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81083
81084   {
81085     try {
81086       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81094       };
81095     } catch (Dali::DaliException e) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81102       };
81103     }
81104   }
81105
81106   jresult = (void *)result;
81107   return jresult;
81108 }
81109
81110
81111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81112   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81113
81114   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81115   {
81116     try {
81117       delete arg1;
81118     } catch (std::out_of_range& e) {
81119       {
81120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81121       };
81122     } catch (std::exception& e) {
81123       {
81124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81125       };
81126     } catch (Dali::DaliException e) {
81127       {
81128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81129       };
81130     } catch (...) {
81131       {
81132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81133       };
81134     }
81135   }
81136
81137 }
81138
81139
81140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81141   void * jresult ;
81142   unsigned int arg1 ;
81143   unsigned int arg2 ;
81144   unsigned int arg3 ;
81145   unsigned int arg4 ;
81146   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81147
81148   arg1 = (unsigned int)jarg1;
81149   arg2 = (unsigned int)jarg2;
81150   arg3 = (unsigned int)jarg3;
81151   arg4 = (unsigned int)jarg4;
81152   {
81153     try {
81154       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
81155     } catch (std::out_of_range& e) {
81156       {
81157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81158       };
81159     } catch (std::exception& e) {
81160       {
81161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81162       };
81163     } catch (Dali::DaliException e) {
81164       {
81165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81166       };
81167     } catch (...) {
81168       {
81169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81170       };
81171     }
81172   }
81173
81174   jresult = (void *)result;
81175   return jresult;
81176 }
81177
81178
81179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81180   void * jresult ;
81181   unsigned int arg1 ;
81182   unsigned int arg2 ;
81183   unsigned int arg3 ;
81184   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81185
81186   arg1 = (unsigned int)jarg1;
81187   arg2 = (unsigned int)jarg2;
81188   arg3 = (unsigned int)jarg3;
81189   {
81190     try {
81191       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81192     } catch (std::out_of_range& e) {
81193       {
81194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (std::exception& e) {
81197       {
81198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (Dali::DaliException e) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81203       };
81204     } catch (...) {
81205       {
81206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81207       };
81208     }
81209   }
81210
81211   jresult = (void *)result;
81212   return jresult;
81213 }
81214
81215
81216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81217   void * jresult ;
81218   unsigned int arg1 ;
81219   unsigned int arg2 ;
81220   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81221
81222   arg1 = (unsigned int)jarg1;
81223   arg2 = (unsigned int)jarg2;
81224   {
81225     try {
81226       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81227     } catch (std::out_of_range& e) {
81228       {
81229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (std::exception& e) {
81232       {
81233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (Dali::DaliException e) {
81236       {
81237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81238       };
81239     } catch (...) {
81240       {
81241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81242       };
81243     }
81244   }
81245
81246   jresult = (void *)result;
81247   return jresult;
81248 }
81249
81250
81251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81252   void * jresult ;
81253   unsigned int arg1 ;
81254   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81255
81256   arg1 = (unsigned int)jarg1;
81257   {
81258     try {
81259       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81260     } catch (std::out_of_range& e) {
81261       {
81262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81263       };
81264     } catch (std::exception& e) {
81265       {
81266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81267       };
81268     } catch (Dali::DaliException e) {
81269       {
81270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81271       };
81272     } catch (...) {
81273       {
81274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81275       };
81276     }
81277   }
81278
81279   jresult = (void *)result;
81280   return jresult;
81281 }
81282
81283
81284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81285   void * jresult ;
81286   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81287
81288   {
81289     try {
81290       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81291     } catch (std::out_of_range& e) {
81292       {
81293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81294       };
81295     } catch (std::exception& e) {
81296       {
81297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81298       };
81299     } catch (Dali::DaliException e) {
81300       {
81301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81302       };
81303     } catch (...) {
81304       {
81305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81306       };
81307     }
81308   }
81309
81310   jresult = (void *)result;
81311   return jresult;
81312 }
81313
81314
81315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81316   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81317   unsigned int arg2 ;
81318
81319   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81320   arg2 = (unsigned int)jarg2;
81321   if (arg1) (arg1)->rowIndex = arg2;
81322 }
81323
81324
81325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81326   unsigned int jresult ;
81327   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81328   unsigned int result;
81329
81330   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81331   result = (unsigned int) ((arg1)->rowIndex);
81332   jresult = result;
81333   return jresult;
81334 }
81335
81336
81337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81338   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81339   unsigned int arg2 ;
81340
81341   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81342   arg2 = (unsigned int)jarg2;
81343   if (arg1) (arg1)->columnIndex = arg2;
81344 }
81345
81346
81347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81348   unsigned int jresult ;
81349   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81350   unsigned int result;
81351
81352   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81353   result = (unsigned int) ((arg1)->columnIndex);
81354   jresult = result;
81355   return jresult;
81356 }
81357
81358
81359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81360   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81361   unsigned int arg2 ;
81362
81363   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81364   arg2 = (unsigned int)jarg2;
81365   if (arg1) (arg1)->rowSpan = arg2;
81366 }
81367
81368
81369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81370   unsigned int jresult ;
81371   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81372   unsigned int result;
81373
81374   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81375   result = (unsigned int) ((arg1)->rowSpan);
81376   jresult = result;
81377   return jresult;
81378 }
81379
81380
81381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81382   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81383   unsigned int arg2 ;
81384
81385   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81386   arg2 = (unsigned int)jarg2;
81387   if (arg1) (arg1)->columnSpan = arg2;
81388 }
81389
81390
81391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81392   unsigned int jresult ;
81393   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81394   unsigned int result;
81395
81396   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81397   result = (unsigned int) ((arg1)->columnSpan);
81398   jresult = result;
81399   return jresult;
81400 }
81401
81402
81403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81404   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81405
81406   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81407   {
81408     try {
81409       delete arg1;
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (Dali::DaliException e) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81421       };
81422     } catch (...) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81425       };
81426     }
81427   }
81428
81429 }
81430
81431
81432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81433   void * jresult ;
81434   Dali::Toolkit::TableView *result = 0 ;
81435
81436   {
81437     try {
81438       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81439     } catch (std::out_of_range& e) {
81440       {
81441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81442       };
81443     } catch (std::exception& e) {
81444       {
81445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81446       };
81447     } catch (Dali::DaliException e) {
81448       {
81449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81450       };
81451     } catch (...) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81454       };
81455     }
81456   }
81457
81458   jresult = (void *)result;
81459   return jresult;
81460 }
81461
81462
81463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81464   void * jresult ;
81465   Dali::Toolkit::TableView *arg1 = 0 ;
81466   Dali::Toolkit::TableView *result = 0 ;
81467
81468   arg1 = (Dali::Toolkit::TableView *)jarg1;
81469   if (!arg1) {
81470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81471     return 0;
81472   }
81473   {
81474     try {
81475       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81491       };
81492     }
81493   }
81494
81495   jresult = (void *)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81501   void * jresult ;
81502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81503   Dali::Toolkit::TableView *arg2 = 0 ;
81504   Dali::Toolkit::TableView *result = 0 ;
81505
81506   arg1 = (Dali::Toolkit::TableView *)jarg1;
81507   arg2 = (Dali::Toolkit::TableView *)jarg2;
81508   if (!arg2) {
81509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81510     return 0;
81511   }
81512   {
81513     try {
81514       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81515     } catch (std::out_of_range& e) {
81516       {
81517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (std::exception& e) {
81520       {
81521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81522       };
81523     } catch (Dali::DaliException e) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81530       };
81531     }
81532   }
81533
81534   jresult = (void *)result;
81535   return jresult;
81536 }
81537
81538
81539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81540   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81541
81542   arg1 = (Dali::Toolkit::TableView *)jarg1;
81543   {
81544     try {
81545       delete arg1;
81546     } catch (std::out_of_range& e) {
81547       {
81548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81549       };
81550     } catch (std::exception& e) {
81551       {
81552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81553       };
81554     } catch (Dali::DaliException e) {
81555       {
81556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81557       };
81558     } catch (...) {
81559       {
81560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81561       };
81562     }
81563   }
81564
81565 }
81566
81567
81568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81569   void * jresult ;
81570   unsigned int arg1 ;
81571   unsigned int arg2 ;
81572   Dali::Toolkit::TableView result;
81573
81574   arg1 = (unsigned int)jarg1;
81575   arg2 = (unsigned int)jarg2;
81576   {
81577     try {
81578       result = Dali::Toolkit::TableView::New(arg1,arg2);
81579     } catch (std::out_of_range& e) {
81580       {
81581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81582       };
81583     } catch (std::exception& e) {
81584       {
81585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81586       };
81587     } catch (Dali::DaliException e) {
81588       {
81589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81590       };
81591     } catch (...) {
81592       {
81593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81594       };
81595     }
81596   }
81597
81598   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81599   return jresult;
81600 }
81601
81602
81603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81604   void * jresult ;
81605   Dali::BaseHandle arg1 ;
81606   Dali::BaseHandle *argp1 ;
81607   Dali::Toolkit::TableView result;
81608
81609   argp1 = (Dali::BaseHandle *)jarg1;
81610   if (!argp1) {
81611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81612     return 0;
81613   }
81614   arg1 = *argp1;
81615   {
81616     try {
81617       result = Dali::Toolkit::TableView::DownCast(arg1);
81618     } catch (std::out_of_range& e) {
81619       {
81620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81621       };
81622     } catch (std::exception& e) {
81623       {
81624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81625       };
81626     } catch (Dali::DaliException e) {
81627       {
81628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81629       };
81630     } catch (...) {
81631       {
81632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81633       };
81634     }
81635   }
81636
81637   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81638   return jresult;
81639 }
81640
81641
81642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81643   unsigned int jresult ;
81644   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81645   Dali::Actor arg2 ;
81646   Dali::Toolkit::TableView::CellPosition arg3 ;
81647   Dali::Actor *argp2 ;
81648   Dali::Toolkit::TableView::CellPosition *argp3 ;
81649   bool result;
81650
81651   arg1 = (Dali::Toolkit::TableView *)jarg1;
81652   argp2 = (Dali::Actor *)jarg2;
81653   if (!argp2) {
81654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81655     return 0;
81656   }
81657   arg2 = *argp2;
81658   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81659   if (!argp3) {
81660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81661     return 0;
81662   }
81663   arg3 = *argp3;
81664   {
81665     try {
81666       result = (bool)(arg1)->AddChild(arg2,arg3);
81667     } catch (std::out_of_range& e) {
81668       {
81669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (std::exception& e) {
81672       {
81673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81674       };
81675     } catch (Dali::DaliException e) {
81676       {
81677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81678       };
81679     } catch (...) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81682       };
81683     }
81684   }
81685
81686   jresult = result;
81687   return jresult;
81688 }
81689
81690
81691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81692   void * jresult ;
81693   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81694   Dali::Toolkit::TableView::CellPosition arg2 ;
81695   Dali::Toolkit::TableView::CellPosition *argp2 ;
81696   Dali::Actor result;
81697
81698   arg1 = (Dali::Toolkit::TableView *)jarg1;
81699   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81700   if (!argp2) {
81701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81702     return 0;
81703   }
81704   arg2 = *argp2;
81705   {
81706     try {
81707       result = (arg1)->GetChildAt(arg2);
81708     } catch (std::out_of_range& e) {
81709       {
81710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81711       };
81712     } catch (std::exception& e) {
81713       {
81714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81715       };
81716     } catch (Dali::DaliException e) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81719       };
81720     } catch (...) {
81721       {
81722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81723       };
81724     }
81725   }
81726
81727   jresult = new Dali::Actor((const Dali::Actor &)result);
81728   return jresult;
81729 }
81730
81731
81732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81733   void * jresult ;
81734   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81735   Dali::Toolkit::TableView::CellPosition arg2 ;
81736   Dali::Toolkit::TableView::CellPosition *argp2 ;
81737   Dali::Actor result;
81738
81739   arg1 = (Dali::Toolkit::TableView *)jarg1;
81740   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81741   if (!argp2) {
81742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81743     return 0;
81744   }
81745   arg2 = *argp2;
81746   {
81747     try {
81748       result = (arg1)->RemoveChildAt(arg2);
81749     } catch (std::out_of_range& e) {
81750       {
81751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81752       };
81753     } catch (std::exception& e) {
81754       {
81755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81756       };
81757     } catch (Dali::DaliException e) {
81758       {
81759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81760       };
81761     } catch (...) {
81762       {
81763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81764       };
81765     }
81766   }
81767
81768   jresult = new Dali::Actor((const Dali::Actor &)result);
81769   return jresult;
81770 }
81771
81772
81773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81774   unsigned int jresult ;
81775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81776   Dali::Actor arg2 ;
81777   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81778   Dali::Actor *argp2 ;
81779   bool result;
81780
81781   arg1 = (Dali::Toolkit::TableView *)jarg1;
81782   argp2 = (Dali::Actor *)jarg2;
81783   if (!argp2) {
81784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81785     return 0;
81786   }
81787   arg2 = *argp2;
81788   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81789   if (!arg3) {
81790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81791     return 0;
81792   }
81793   {
81794     try {
81795       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81796     } catch (std::out_of_range& e) {
81797       {
81798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81799       };
81800     } catch (std::exception& e) {
81801       {
81802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81803       };
81804     } catch (Dali::DaliException e) {
81805       {
81806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81807       };
81808     } catch (...) {
81809       {
81810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81811       };
81812     }
81813   }
81814
81815   jresult = result;
81816   return jresult;
81817 }
81818
81819
81820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81821   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81822   unsigned int arg2 ;
81823
81824   arg1 = (Dali::Toolkit::TableView *)jarg1;
81825   arg2 = (unsigned int)jarg2;
81826   {
81827     try {
81828       (arg1)->InsertRow(arg2);
81829     } catch (std::out_of_range& e) {
81830       {
81831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81832       };
81833     } catch (std::exception& e) {
81834       {
81835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81836       };
81837     } catch (Dali::DaliException e) {
81838       {
81839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81840       };
81841     } catch (...) {
81842       {
81843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81844       };
81845     }
81846   }
81847
81848 }
81849
81850
81851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81852   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81853   unsigned int arg2 ;
81854
81855   arg1 = (Dali::Toolkit::TableView *)jarg1;
81856   arg2 = (unsigned int)jarg2;
81857   {
81858     try {
81859       (arg1)->DeleteRow(arg2);
81860     } catch (std::out_of_range& e) {
81861       {
81862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81863       };
81864     } catch (std::exception& e) {
81865       {
81866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81867       };
81868     } catch (Dali::DaliException e) {
81869       {
81870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81871       };
81872     } catch (...) {
81873       {
81874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81875       };
81876     }
81877   }
81878
81879 }
81880
81881
81882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81883   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81884   unsigned int arg2 ;
81885   std::vector< Dali::Actor > *arg3 = 0 ;
81886
81887   arg1 = (Dali::Toolkit::TableView *)jarg1;
81888   arg2 = (unsigned int)jarg2;
81889   arg3 = (std::vector< Dali::Actor > *)jarg3;
81890   if (!arg3) {
81891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81892     return ;
81893   }
81894   {
81895     try {
81896       (arg1)->DeleteRow(arg2,*arg3);
81897     } catch (std::out_of_range& e) {
81898       {
81899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81900       };
81901     } catch (std::exception& e) {
81902       {
81903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81904       };
81905     } catch (Dali::DaliException e) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81908       };
81909     } catch (...) {
81910       {
81911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81912       };
81913     }
81914   }
81915
81916 }
81917
81918
81919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81920   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81921   unsigned int arg2 ;
81922
81923   arg1 = (Dali::Toolkit::TableView *)jarg1;
81924   arg2 = (unsigned int)jarg2;
81925   {
81926     try {
81927       (arg1)->InsertColumn(arg2);
81928     } catch (std::out_of_range& e) {
81929       {
81930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81931       };
81932     } catch (std::exception& e) {
81933       {
81934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81935       };
81936     } catch (Dali::DaliException e) {
81937       {
81938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81939       };
81940     } catch (...) {
81941       {
81942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81943       };
81944     }
81945   }
81946
81947 }
81948
81949
81950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
81951   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81952   unsigned int arg2 ;
81953
81954   arg1 = (Dali::Toolkit::TableView *)jarg1;
81955   arg2 = (unsigned int)jarg2;
81956   {
81957     try {
81958       (arg1)->DeleteColumn(arg2);
81959     } catch (std::out_of_range& e) {
81960       {
81961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81962       };
81963     } catch (std::exception& e) {
81964       {
81965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81966       };
81967     } catch (Dali::DaliException e) {
81968       {
81969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81970       };
81971     } catch (...) {
81972       {
81973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81974       };
81975     }
81976   }
81977
81978 }
81979
81980
81981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81982   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81983   unsigned int arg2 ;
81984   std::vector< Dali::Actor > *arg3 = 0 ;
81985
81986   arg1 = (Dali::Toolkit::TableView *)jarg1;
81987   arg2 = (unsigned int)jarg2;
81988   arg3 = (std::vector< Dali::Actor > *)jarg3;
81989   if (!arg3) {
81990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81991     return ;
81992   }
81993   {
81994     try {
81995       (arg1)->DeleteColumn(arg2,*arg3);
81996     } catch (std::out_of_range& e) {
81997       {
81998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81999       };
82000     } catch (std::exception& e) {
82001       {
82002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82003       };
82004     } catch (Dali::DaliException e) {
82005       {
82006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82007       };
82008     } catch (...) {
82009       {
82010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82011       };
82012     }
82013   }
82014
82015 }
82016
82017
82018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82019   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82020   unsigned int arg2 ;
82021   unsigned int arg3 ;
82022
82023   arg1 = (Dali::Toolkit::TableView *)jarg1;
82024   arg2 = (unsigned int)jarg2;
82025   arg3 = (unsigned int)jarg3;
82026   {
82027     try {
82028       (arg1)->Resize(arg2,arg3);
82029     } catch (std::out_of_range& e) {
82030       {
82031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82032       };
82033     } catch (std::exception& e) {
82034       {
82035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82036       };
82037     } catch (Dali::DaliException e) {
82038       {
82039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82040       };
82041     } catch (...) {
82042       {
82043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82044       };
82045     }
82046   }
82047
82048 }
82049
82050
82051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82052   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82053   unsigned int arg2 ;
82054   unsigned int arg3 ;
82055   std::vector< Dali::Actor > *arg4 = 0 ;
82056
82057   arg1 = (Dali::Toolkit::TableView *)jarg1;
82058   arg2 = (unsigned int)jarg2;
82059   arg3 = (unsigned int)jarg3;
82060   arg4 = (std::vector< Dali::Actor > *)jarg4;
82061   if (!arg4) {
82062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82063     return ;
82064   }
82065   {
82066     try {
82067       (arg1)->Resize(arg2,arg3,*arg4);
82068     } catch (std::out_of_range& e) {
82069       {
82070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82071       };
82072     } catch (std::exception& e) {
82073       {
82074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82075       };
82076     } catch (Dali::DaliException e) {
82077       {
82078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82079       };
82080     } catch (...) {
82081       {
82082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82083       };
82084     }
82085   }
82086
82087 }
82088
82089
82090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82092   Dali::Size arg2 ;
82093   Dali::Size *argp2 ;
82094
82095   arg1 = (Dali::Toolkit::TableView *)jarg1;
82096   argp2 = (Dali::Size *)jarg2;
82097   if (!argp2) {
82098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82099     return ;
82100   }
82101   arg2 = *argp2;
82102   {
82103     try {
82104       (arg1)->SetCellPadding(arg2);
82105     } catch (std::out_of_range& e) {
82106       {
82107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82108       };
82109     } catch (std::exception& e) {
82110       {
82111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82112       };
82113     } catch (Dali::DaliException e) {
82114       {
82115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82116       };
82117     } catch (...) {
82118       {
82119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82120       };
82121     }
82122   }
82123
82124 }
82125
82126
82127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82128   void * jresult ;
82129   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82130   Dali::Size result;
82131
82132   arg1 = (Dali::Toolkit::TableView *)jarg1;
82133   {
82134     try {
82135       result = (arg1)->GetCellPadding();
82136     } catch (std::out_of_range& e) {
82137       {
82138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82139       };
82140     } catch (std::exception& e) {
82141       {
82142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82143       };
82144     } catch (Dali::DaliException e) {
82145       {
82146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82147       };
82148     } catch (...) {
82149       {
82150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82151       };
82152     }
82153   }
82154
82155   jresult = new Dali::Size((const Dali::Size &)result);
82156   return jresult;
82157 }
82158
82159
82160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82161   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82162   unsigned int arg2 ;
82163
82164   arg1 = (Dali::Toolkit::TableView *)jarg1;
82165   arg2 = (unsigned int)jarg2;
82166   {
82167     try {
82168       (arg1)->SetFitHeight(arg2);
82169     } catch (std::out_of_range& e) {
82170       {
82171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82172       };
82173     } catch (std::exception& e) {
82174       {
82175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82176       };
82177     } catch (Dali::DaliException e) {
82178       {
82179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82180       };
82181     } catch (...) {
82182       {
82183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82184       };
82185     }
82186   }
82187
82188 }
82189
82190
82191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82192   unsigned int jresult ;
82193   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82194   unsigned int arg2 ;
82195   bool result;
82196
82197   arg1 = (Dali::Toolkit::TableView *)jarg1;
82198   arg2 = (unsigned int)jarg2;
82199   {
82200     try {
82201       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82202     } catch (std::out_of_range& e) {
82203       {
82204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82205       };
82206     } catch (std::exception& e) {
82207       {
82208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82209       };
82210     } catch (Dali::DaliException e) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82213       };
82214     } catch (...) {
82215       {
82216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82217       };
82218     }
82219   }
82220
82221   jresult = result;
82222   return jresult;
82223 }
82224
82225
82226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82227   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82228   unsigned int arg2 ;
82229
82230   arg1 = (Dali::Toolkit::TableView *)jarg1;
82231   arg2 = (unsigned int)jarg2;
82232   {
82233     try {
82234       (arg1)->SetFitWidth(arg2);
82235     } catch (std::out_of_range& e) {
82236       {
82237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82238       };
82239     } catch (std::exception& e) {
82240       {
82241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82242       };
82243     } catch (Dali::DaliException e) {
82244       {
82245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82246       };
82247     } catch (...) {
82248       {
82249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82250       };
82251     }
82252   }
82253
82254 }
82255
82256
82257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82258   unsigned int jresult ;
82259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82260   unsigned int arg2 ;
82261   bool result;
82262
82263   arg1 = (Dali::Toolkit::TableView *)jarg1;
82264   arg2 = (unsigned int)jarg2;
82265   {
82266     try {
82267       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82268     } catch (std::out_of_range& e) {
82269       {
82270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82271       };
82272     } catch (std::exception& e) {
82273       {
82274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82275       };
82276     } catch (Dali::DaliException e) {
82277       {
82278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82279       };
82280     } catch (...) {
82281       {
82282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82283       };
82284     }
82285   }
82286
82287   jresult = result;
82288   return jresult;
82289 }
82290
82291
82292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82293   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82294   unsigned int arg2 ;
82295   float arg3 ;
82296
82297   arg1 = (Dali::Toolkit::TableView *)jarg1;
82298   arg2 = (unsigned int)jarg2;
82299   arg3 = (float)jarg3;
82300   {
82301     try {
82302       (arg1)->SetFixedHeight(arg2,arg3);
82303     } catch (std::out_of_range& e) {
82304       {
82305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (std::exception& e) {
82308       {
82309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82310       };
82311     } catch (Dali::DaliException e) {
82312       {
82313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82314       };
82315     } catch (...) {
82316       {
82317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82318       };
82319     }
82320   }
82321
82322 }
82323
82324
82325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82326   float jresult ;
82327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82328   unsigned int arg2 ;
82329   float result;
82330
82331   arg1 = (Dali::Toolkit::TableView *)jarg1;
82332   arg2 = (unsigned int)jarg2;
82333   {
82334     try {
82335       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82336     } catch (std::out_of_range& e) {
82337       {
82338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82339       };
82340     } catch (std::exception& e) {
82341       {
82342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82343       };
82344     } catch (Dali::DaliException e) {
82345       {
82346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82347       };
82348     } catch (...) {
82349       {
82350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82351       };
82352     }
82353   }
82354
82355   jresult = result;
82356   return jresult;
82357 }
82358
82359
82360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82361   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82362   unsigned int arg2 ;
82363   float arg3 ;
82364
82365   arg1 = (Dali::Toolkit::TableView *)jarg1;
82366   arg2 = (unsigned int)jarg2;
82367   arg3 = (float)jarg3;
82368   {
82369     try {
82370       (arg1)->SetRelativeHeight(arg2,arg3);
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82378       };
82379     } catch (Dali::DaliException e) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82386       };
82387     }
82388   }
82389
82390 }
82391
82392
82393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82394   float jresult ;
82395   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82396   unsigned int arg2 ;
82397   float result;
82398
82399   arg1 = (Dali::Toolkit::TableView *)jarg1;
82400   arg2 = (unsigned int)jarg2;
82401   {
82402     try {
82403       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82404     } catch (std::out_of_range& e) {
82405       {
82406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (std::exception& e) {
82409       {
82410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (Dali::DaliException e) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82415       };
82416     } catch (...) {
82417       {
82418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82419       };
82420     }
82421   }
82422
82423   jresult = result;
82424   return jresult;
82425 }
82426
82427
82428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82430   unsigned int arg2 ;
82431   float arg3 ;
82432
82433   arg1 = (Dali::Toolkit::TableView *)jarg1;
82434   arg2 = (unsigned int)jarg2;
82435   arg3 = (float)jarg3;
82436   {
82437     try {
82438       (arg1)->SetFixedWidth(arg2,arg3);
82439     } catch (std::out_of_range& e) {
82440       {
82441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82442       };
82443     } catch (std::exception& e) {
82444       {
82445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82446       };
82447     } catch (Dali::DaliException e) {
82448       {
82449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82450       };
82451     } catch (...) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82454       };
82455     }
82456   }
82457
82458 }
82459
82460
82461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82462   float jresult ;
82463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82464   unsigned int arg2 ;
82465   float result;
82466
82467   arg1 = (Dali::Toolkit::TableView *)jarg1;
82468   arg2 = (unsigned int)jarg2;
82469   {
82470     try {
82471       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82472     } catch (std::out_of_range& e) {
82473       {
82474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82475       };
82476     } catch (std::exception& e) {
82477       {
82478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82479       };
82480     } catch (Dali::DaliException e) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82483       };
82484     } catch (...) {
82485       {
82486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82487       };
82488     }
82489   }
82490
82491   jresult = result;
82492   return jresult;
82493 }
82494
82495
82496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82498   unsigned int arg2 ;
82499   float arg3 ;
82500
82501   arg1 = (Dali::Toolkit::TableView *)jarg1;
82502   arg2 = (unsigned int)jarg2;
82503   arg3 = (float)jarg3;
82504   {
82505     try {
82506       (arg1)->SetRelativeWidth(arg2,arg3);
82507     } catch (std::out_of_range& e) {
82508       {
82509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82510       };
82511     } catch (std::exception& e) {
82512       {
82513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82514       };
82515     } catch (Dali::DaliException e) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82518       };
82519     } catch (...) {
82520       {
82521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82522       };
82523     }
82524   }
82525
82526 }
82527
82528
82529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82530   float jresult ;
82531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82532   unsigned int arg2 ;
82533   float result;
82534
82535   arg1 = (Dali::Toolkit::TableView *)jarg1;
82536   arg2 = (unsigned int)jarg2;
82537   {
82538     try {
82539       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82540     } catch (std::out_of_range& e) {
82541       {
82542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82543       };
82544     } catch (std::exception& e) {
82545       {
82546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82547       };
82548     } catch (Dali::DaliException e) {
82549       {
82550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82551       };
82552     } catch (...) {
82553       {
82554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82555       };
82556     }
82557   }
82558
82559   jresult = result;
82560   return jresult;
82561 }
82562
82563
82564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82565   unsigned int jresult ;
82566   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82567   unsigned int result;
82568
82569   arg1 = (Dali::Toolkit::TableView *)jarg1;
82570   {
82571     try {
82572       result = (unsigned int)(arg1)->GetRows();
82573     } catch (std::out_of_range& e) {
82574       {
82575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82576       };
82577     } catch (std::exception& e) {
82578       {
82579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82580       };
82581     } catch (Dali::DaliException e) {
82582       {
82583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82584       };
82585     } catch (...) {
82586       {
82587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82588       };
82589     }
82590   }
82591
82592   jresult = result;
82593   return jresult;
82594 }
82595
82596
82597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82598   unsigned int jresult ;
82599   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82600   unsigned int result;
82601
82602   arg1 = (Dali::Toolkit::TableView *)jarg1;
82603   {
82604     try {
82605       result = (unsigned int)(arg1)->GetColumns();
82606     } catch (std::out_of_range& e) {
82607       {
82608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82609       };
82610     } catch (std::exception& e) {
82611       {
82612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82613       };
82614     } catch (Dali::DaliException e) {
82615       {
82616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82617       };
82618     } catch (...) {
82619       {
82620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82621       };
82622     }
82623   }
82624
82625   jresult = result;
82626   return jresult;
82627 }
82628
82629
82630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82631   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82632   Dali::Toolkit::TableView::CellPosition arg2 ;
82633   Dali::HorizontalAlignment::Type arg3 ;
82634   Dali::VerticalAlignment::Type arg4 ;
82635   Dali::Toolkit::TableView::CellPosition *argp2 ;
82636
82637   arg1 = (Dali::Toolkit::TableView *)jarg1;
82638   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82639   if (!argp2) {
82640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82641     return ;
82642   }
82643   arg2 = *argp2;
82644   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82645   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82646   {
82647     try {
82648       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82656       };
82657     } catch (Dali::DaliException e) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82664       };
82665     }
82666   }
82667
82668 }
82669
82670
82671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82672   unsigned int jresult ;
82673   unsigned int result;
82674
82675   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82676   jresult = result;
82677   return jresult;
82678 }
82679
82680
82681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82682   int jresult ;
82683   int result;
82684
82685   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82686   jresult = (int)result;
82687   return jresult;
82688 }
82689
82690
82691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82692   int jresult ;
82693   int result;
82694
82695   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82696   jresult = (int)result;
82697   return jresult;
82698 }
82699
82700
82701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82702   int jresult ;
82703   int result;
82704
82705   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82706   jresult = (int)result;
82707   return jresult;
82708 }
82709
82710
82711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82712   int jresult ;
82713   int result;
82714
82715   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82716   jresult = (int)result;
82717   return jresult;
82718 }
82719
82720
82721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82722   int jresult ;
82723   int result;
82724
82725   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82726   jresult = (int)result;
82727   return jresult;
82728 }
82729
82730
82731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82732   int jresult ;
82733   int result;
82734
82735   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82736   jresult = (int)result;
82737   return jresult;
82738 }
82739
82740
82741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82742   int jresult ;
82743   int result;
82744
82745   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82746   jresult = (int)result;
82747   return jresult;
82748 }
82749
82750
82751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82752   int jresult ;
82753   int result;
82754
82755   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82756   jresult = (int)result;
82757   return jresult;
82758 }
82759
82760
82761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82762   int jresult ;
82763   int result;
82764
82765   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82766   jresult = (int)result;
82767   return jresult;
82768 }
82769
82770
82771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82772   int jresult ;
82773   int result;
82774
82775   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82776   jresult = (int)result;
82777   return jresult;
82778 }
82779
82780
82781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82782   int jresult ;
82783   int result;
82784
82785   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82786   jresult = (int)result;
82787   return jresult;
82788 }
82789
82790
82791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82792   int jresult ;
82793   int result;
82794
82795   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82796   jresult = (int)result;
82797   return jresult;
82798 }
82799
82800
82801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82802   int jresult ;
82803   int result;
82804
82805   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82806   jresult = (int)result;
82807   return jresult;
82808 }
82809
82810
82811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82812   int jresult ;
82813   int result;
82814
82815   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82816   jresult = (int)result;
82817   return jresult;
82818 }
82819
82820
82821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82822   int jresult ;
82823   int result;
82824
82825   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82826   jresult = (int)result;
82827   return jresult;
82828 }
82829
82830
82831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82832   int jresult ;
82833   int result;
82834
82835   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82836   jresult = (int)result;
82837   return jresult;
82838 }
82839
82840
82841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82842   int jresult ;
82843   int result;
82844
82845   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82846   jresult = (int)result;
82847   return jresult;
82848 }
82849
82850
82851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82852   int jresult ;
82853   int result;
82854
82855   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82856   jresult = (int)result;
82857   return jresult;
82858 }
82859
82860
82861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82862   int jresult ;
82863   int result;
82864
82865   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82866   jresult = (int)result;
82867   return jresult;
82868 }
82869
82870
82871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82872   void * jresult ;
82873   Dali::Toolkit::TextLabel::Property *result = 0 ;
82874
82875   {
82876     try {
82877       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82878     } catch (std::out_of_range& e) {
82879       {
82880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82881       };
82882     } catch (std::exception& e) {
82883       {
82884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82885       };
82886     } catch (Dali::DaliException e) {
82887       {
82888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82889       };
82890     } catch (...) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82893       };
82894     }
82895   }
82896
82897   jresult = (void *)result;
82898   return jresult;
82899 }
82900
82901
82902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82903   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82904
82905   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82906   {
82907     try {
82908       delete arg1;
82909     } catch (std::out_of_range& e) {
82910       {
82911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82912       };
82913     } catch (std::exception& e) {
82914       {
82915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82916       };
82917     } catch (Dali::DaliException e) {
82918       {
82919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82920       };
82921     } catch (...) {
82922       {
82923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82924       };
82925     }
82926   }
82927
82928 }
82929
82930
82931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
82932   void * jresult ;
82933   Dali::Toolkit::TextLabel result;
82934
82935   {
82936     try {
82937       result = Dali::Toolkit::TextLabel::New();
82938     } catch (std::out_of_range& e) {
82939       {
82940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82941       };
82942     } catch (std::exception& e) {
82943       {
82944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82945       };
82946     } catch (Dali::DaliException e) {
82947       {
82948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82949       };
82950     } catch (...) {
82951       {
82952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82953       };
82954     }
82955   }
82956
82957   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
82963   void * jresult ;
82964   std::string *arg1 = 0 ;
82965   Dali::Toolkit::TextLabel result;
82966
82967   if (!jarg1) {
82968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82969     return 0;
82970   }
82971   std::string arg1_str(jarg1);
82972   arg1 = &arg1_str;
82973   {
82974     try {
82975       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
82976     } catch (std::out_of_range& e) {
82977       {
82978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82979       };
82980     } catch (std::exception& e) {
82981       {
82982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82983       };
82984     } catch (Dali::DaliException e) {
82985       {
82986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82987       };
82988     } catch (...) {
82989       {
82990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82991       };
82992     }
82993   }
82994
82995   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82996
82997   //argout typemap for const std::string&
82998
82999   return jresult;
83000 }
83001
83002
83003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83004   void * jresult ;
83005   Dali::Toolkit::TextLabel *result = 0 ;
83006
83007   {
83008     try {
83009       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83010     } catch (std::out_of_range& e) {
83011       {
83012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83013       };
83014     } catch (std::exception& e) {
83015       {
83016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83017       };
83018     } catch (Dali::DaliException e) {
83019       {
83020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83021       };
83022     } catch (...) {
83023       {
83024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83025       };
83026     }
83027   }
83028
83029   jresult = (void *)result;
83030   return jresult;
83031 }
83032
83033
83034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83035   void * jresult ;
83036   Dali::Toolkit::TextLabel *arg1 = 0 ;
83037   Dali::Toolkit::TextLabel *result = 0 ;
83038
83039   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83040   if (!arg1) {
83041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83042     return 0;
83043   }
83044   {
83045     try {
83046       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83047     } catch (std::out_of_range& e) {
83048       {
83049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83050       };
83051     } catch (std::exception& e) {
83052       {
83053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83054       };
83055     } catch (Dali::DaliException e) {
83056       {
83057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83058       };
83059     } catch (...) {
83060       {
83061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83062       };
83063     }
83064   }
83065
83066   jresult = (void *)result;
83067   return jresult;
83068 }
83069
83070
83071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83072   void * jresult ;
83073   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83074   Dali::Toolkit::TextLabel *arg2 = 0 ;
83075   Dali::Toolkit::TextLabel *result = 0 ;
83076
83077   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83078   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83079   if (!arg2) {
83080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83081     return 0;
83082   }
83083   {
83084     try {
83085       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (Dali::DaliException e) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83097       };
83098     } catch (...) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83101       };
83102     }
83103   }
83104
83105   jresult = (void *)result;
83106   return jresult;
83107 }
83108
83109
83110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83111   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83112
83113   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83114   {
83115     try {
83116       delete arg1;
83117     } catch (std::out_of_range& e) {
83118       {
83119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83120       };
83121     } catch (std::exception& e) {
83122       {
83123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83124       };
83125     } catch (Dali::DaliException e) {
83126       {
83127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83128       };
83129     } catch (...) {
83130       {
83131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83132       };
83133     }
83134   }
83135
83136 }
83137
83138
83139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83140   void * jresult ;
83141   Dali::BaseHandle arg1 ;
83142   Dali::BaseHandle *argp1 ;
83143   Dali::Toolkit::TextLabel result;
83144
83145   argp1 = (Dali::BaseHandle *)jarg1;
83146   if (!argp1) {
83147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83148     return 0;
83149   }
83150   arg1 = *argp1;
83151   {
83152     try {
83153       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83154     } catch (std::out_of_range& e) {
83155       {
83156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83157       };
83158     } catch (std::exception& e) {
83159       {
83160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83161       };
83162     } catch (Dali::DaliException e) {
83163       {
83164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83165       };
83166     } catch (...) {
83167       {
83168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83169       };
83170     }
83171   }
83172
83173   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83174   return jresult;
83175 }
83176
83177
83178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83179   void * jresult ;
83180   Dali::Toolkit::AccessibilityManager *result = 0 ;
83181
83182   {
83183     try {
83184       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83185     } catch (std::out_of_range& e) {
83186       {
83187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (std::exception& e) {
83190       {
83191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (Dali::DaliException e) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83200       };
83201     }
83202   }
83203
83204   jresult = (void *)result;
83205   return jresult;
83206 }
83207
83208
83209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83211
83212   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83213   {
83214     try {
83215       delete arg1;
83216     } catch (std::out_of_range& e) {
83217       {
83218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83219       };
83220     } catch (std::exception& e) {
83221       {
83222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83223       };
83224     } catch (Dali::DaliException e) {
83225       {
83226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83227       };
83228     } catch (...) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83231       };
83232     }
83233   }
83234
83235 }
83236
83237
83238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83239   void * jresult ;
83240   Dali::Toolkit::AccessibilityManager result;
83241
83242   {
83243     try {
83244       result = Dali::Toolkit::AccessibilityManager::Get();
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (Dali::DaliException e) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83260       };
83261     }
83262   }
83263
83264   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83265   return jresult;
83266 }
83267
83268
83269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83271   Dali::Actor arg2 ;
83272   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83273   std::string *arg4 = 0 ;
83274   Dali::Actor *argp2 ;
83275
83276   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83277   argp2 = (Dali::Actor *)jarg2;
83278   if (!argp2) {
83279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83280     return ;
83281   }
83282   arg2 = *argp2;
83283   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83284   if (!jarg4) {
83285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83286     return ;
83287   }
83288   std::string arg4_str(jarg4);
83289   arg4 = &arg4_str;
83290   {
83291     try {
83292       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83293     } catch (std::out_of_range& e) {
83294       {
83295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83296       };
83297     } catch (std::exception& e) {
83298       {
83299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83300       };
83301     } catch (Dali::DaliException e) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83304       };
83305     } catch (...) {
83306       {
83307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83308       };
83309     }
83310   }
83311
83312
83313   //argout typemap for const std::string&
83314
83315 }
83316
83317
83318 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83319   char * jresult ;
83320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83321   Dali::Actor arg2 ;
83322   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83323   Dali::Actor *argp2 ;
83324   std::string result;
83325
83326   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83327   argp2 = (Dali::Actor *)jarg2;
83328   if (!argp2) {
83329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83330     return 0;
83331   }
83332   arg2 = *argp2;
83333   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83334   {
83335     try {
83336       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83337     } catch (std::out_of_range& e) {
83338       {
83339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83340       };
83341     } catch (std::exception& e) {
83342       {
83343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83344       };
83345     } catch (Dali::DaliException e) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83348       };
83349     } catch (...) {
83350       {
83351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83352       };
83353     }
83354   }
83355
83356   jresult = SWIG_csharp_string_callback((&result)->c_str());
83357   return jresult;
83358 }
83359
83360
83361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83363   Dali::Actor arg2 ;
83364   unsigned int arg3 ;
83365   Dali::Actor *argp2 ;
83366
83367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83368   argp2 = (Dali::Actor *)jarg2;
83369   if (!argp2) {
83370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83371     return ;
83372   }
83373   arg2 = *argp2;
83374   arg3 = (unsigned int)jarg3;
83375   {
83376     try {
83377       (arg1)->SetFocusOrder(arg2,arg3);
83378     } catch (std::out_of_range& e) {
83379       {
83380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83381       };
83382     } catch (std::exception& e) {
83383       {
83384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83385       };
83386     } catch (Dali::DaliException e) {
83387       {
83388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83393       };
83394     }
83395   }
83396
83397 }
83398
83399
83400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83401   unsigned int jresult ;
83402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83403   Dali::Actor arg2 ;
83404   Dali::Actor *argp2 ;
83405   unsigned int result;
83406
83407   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83408   argp2 = (Dali::Actor *)jarg2;
83409   if (!argp2) {
83410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83411     return 0;
83412   }
83413   arg2 = *argp2;
83414   {
83415     try {
83416       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83417     } catch (std::out_of_range& e) {
83418       {
83419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83420       };
83421     } catch (std::exception& e) {
83422       {
83423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83424       };
83425     } catch (Dali::DaliException e) {
83426       {
83427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83428       };
83429     } catch (...) {
83430       {
83431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83432       };
83433     }
83434   }
83435
83436   jresult = result;
83437   return jresult;
83438 }
83439
83440
83441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83442   unsigned int jresult ;
83443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83444   unsigned int result;
83445
83446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83447   {
83448     try {
83449       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83450     } catch (std::out_of_range& e) {
83451       {
83452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (std::exception& e) {
83455       {
83456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83457       };
83458     } catch (Dali::DaliException e) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83461       };
83462     } catch (...) {
83463       {
83464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83465       };
83466     }
83467   }
83468
83469   jresult = result;
83470   return jresult;
83471 }
83472
83473
83474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83475   void * jresult ;
83476   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83477   unsigned int arg2 ;
83478   Dali::Actor result;
83479
83480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83481   arg2 = (unsigned int)jarg2;
83482   {
83483     try {
83484       result = (arg1)->GetActorByFocusOrder(arg2);
83485     } catch (std::out_of_range& e) {
83486       {
83487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83488       };
83489     } catch (std::exception& e) {
83490       {
83491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (Dali::DaliException e) {
83494       {
83495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83496       };
83497     } catch (...) {
83498       {
83499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83500       };
83501     }
83502   }
83503
83504   jresult = new Dali::Actor((const Dali::Actor &)result);
83505   return jresult;
83506 }
83507
83508
83509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83510   unsigned int jresult ;
83511   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83512   Dali::Actor arg2 ;
83513   Dali::Actor *argp2 ;
83514   bool result;
83515
83516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83517   argp2 = (Dali::Actor *)jarg2;
83518   if (!argp2) {
83519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83520     return 0;
83521   }
83522   arg2 = *argp2;
83523   {
83524     try {
83525       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83526     } catch (std::out_of_range& e) {
83527       {
83528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83529       };
83530     } catch (std::exception& e) {
83531       {
83532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83533       };
83534     } catch (Dali::DaliException e) {
83535       {
83536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83537       };
83538     } catch (...) {
83539       {
83540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83541       };
83542     }
83543   }
83544
83545   jresult = result;
83546   return jresult;
83547 }
83548
83549
83550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83551   void * jresult ;
83552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83553   Dali::Actor result;
83554
83555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83556   {
83557     try {
83558       result = (arg1)->GetCurrentFocusActor();
83559     } catch (std::out_of_range& e) {
83560       {
83561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (std::exception& e) {
83564       {
83565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83566       };
83567     } catch (Dali::DaliException e) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83570       };
83571     } catch (...) {
83572       {
83573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83574       };
83575     }
83576   }
83577
83578   jresult = new Dali::Actor((const Dali::Actor &)result);
83579   return jresult;
83580 }
83581
83582
83583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83584   void * jresult ;
83585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83586   Dali::Actor result;
83587
83588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83589   {
83590     try {
83591       result = (arg1)->GetCurrentFocusGroup();
83592     } catch (std::out_of_range& e) {
83593       {
83594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83595       };
83596     } catch (std::exception& e) {
83597       {
83598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83599       };
83600     } catch (Dali::DaliException e) {
83601       {
83602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83603       };
83604     } catch (...) {
83605       {
83606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83607       };
83608     }
83609   }
83610
83611   jresult = new Dali::Actor((const Dali::Actor &)result);
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83617   unsigned int jresult ;
83618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83619   unsigned int result;
83620
83621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83622   {
83623     try {
83624       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83625     } catch (std::out_of_range& e) {
83626       {
83627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83628       };
83629     } catch (std::exception& e) {
83630       {
83631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83632       };
83633     } catch (Dali::DaliException e) {
83634       {
83635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83636       };
83637     } catch (...) {
83638       {
83639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83640       };
83641     }
83642   }
83643
83644   jresult = result;
83645   return jresult;
83646 }
83647
83648
83649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83650   unsigned int jresult ;
83651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83652   bool result;
83653
83654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83655   {
83656     try {
83657       result = (bool)(arg1)->MoveFocusForward();
83658     } catch (std::out_of_range& e) {
83659       {
83660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83661       };
83662     } catch (std::exception& e) {
83663       {
83664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83665       };
83666     } catch (Dali::DaliException e) {
83667       {
83668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83669       };
83670     } catch (...) {
83671       {
83672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83673       };
83674     }
83675   }
83676
83677   jresult = result;
83678   return jresult;
83679 }
83680
83681
83682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83683   unsigned int jresult ;
83684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83685   bool result;
83686
83687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83688   {
83689     try {
83690       result = (bool)(arg1)->MoveFocusBackward();
83691     } catch (std::out_of_range& e) {
83692       {
83693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (std::exception& e) {
83696       {
83697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83698       };
83699     } catch (Dali::DaliException e) {
83700       {
83701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83702       };
83703     } catch (...) {
83704       {
83705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83706       };
83707     }
83708   }
83709
83710   jresult = result;
83711   return jresult;
83712 }
83713
83714
83715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83717
83718   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83719   {
83720     try {
83721       (arg1)->ClearFocus();
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83729       };
83730     } catch (Dali::DaliException e) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83733       };
83734     } catch (...) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83737       };
83738     }
83739   }
83740
83741 }
83742
83743
83744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83745   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83746
83747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83748   {
83749     try {
83750       (arg1)->Reset();
83751     } catch (std::out_of_range& e) {
83752       {
83753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83754       };
83755     } catch (std::exception& e) {
83756       {
83757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83758       };
83759     } catch (Dali::DaliException e) {
83760       {
83761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83762       };
83763     } catch (...) {
83764       {
83765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83766       };
83767     }
83768   }
83769
83770 }
83771
83772
83773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83775   Dali::Actor arg2 ;
83776   bool arg3 ;
83777   Dali::Actor *argp2 ;
83778
83779   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83780   argp2 = (Dali::Actor *)jarg2;
83781   if (!argp2) {
83782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83783     return ;
83784   }
83785   arg2 = *argp2;
83786   arg3 = jarg3 ? true : false;
83787   {
83788     try {
83789       (arg1)->SetFocusGroup(arg2,arg3);
83790     } catch (std::out_of_range& e) {
83791       {
83792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83793       };
83794     } catch (std::exception& e) {
83795       {
83796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83797       };
83798     } catch (Dali::DaliException e) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83801       };
83802     } catch (...) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83805       };
83806     }
83807   }
83808
83809 }
83810
83811
83812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83813   unsigned int jresult ;
83814   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83815   Dali::Actor arg2 ;
83816   Dali::Actor *argp2 ;
83817   bool result;
83818
83819   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83820   argp2 = (Dali::Actor *)jarg2;
83821   if (!argp2) {
83822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83823     return 0;
83824   }
83825   arg2 = *argp2;
83826   {
83827     try {
83828       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83829     } catch (std::out_of_range& e) {
83830       {
83831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (std::exception& e) {
83834       {
83835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83836       };
83837     } catch (Dali::DaliException e) {
83838       {
83839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83840       };
83841     } catch (...) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83844       };
83845     }
83846   }
83847
83848   jresult = result;
83849   return jresult;
83850 }
83851
83852
83853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83855   bool arg2 ;
83856
83857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83858   arg2 = jarg2 ? true : false;
83859   {
83860     try {
83861       (arg1)->SetGroupMode(arg2);
83862     } catch (std::out_of_range& e) {
83863       {
83864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83865       };
83866     } catch (std::exception& e) {
83867       {
83868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83869       };
83870     } catch (Dali::DaliException e) {
83871       {
83872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83873       };
83874     } catch (...) {
83875       {
83876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83877       };
83878     }
83879   }
83880
83881 }
83882
83883
83884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83885   unsigned int jresult ;
83886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83887   bool result;
83888
83889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83890   {
83891     try {
83892       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83893     } catch (std::out_of_range& e) {
83894       {
83895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83896       };
83897     } catch (std::exception& e) {
83898       {
83899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83900       };
83901     } catch (Dali::DaliException e) {
83902       {
83903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83904       };
83905     } catch (...) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83908       };
83909     }
83910   }
83911
83912   jresult = result;
83913   return jresult;
83914 }
83915
83916
83917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83919   bool arg2 ;
83920
83921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83922   arg2 = jarg2 ? true : false;
83923   {
83924     try {
83925       (arg1)->SetWrapMode(arg2);
83926     } catch (std::out_of_range& e) {
83927       {
83928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83929       };
83930     } catch (std::exception& e) {
83931       {
83932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83933       };
83934     } catch (Dali::DaliException e) {
83935       {
83936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83937       };
83938     } catch (...) {
83939       {
83940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83941       };
83942     }
83943   }
83944
83945 }
83946
83947
83948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
83949   unsigned int jresult ;
83950   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83951   bool result;
83952
83953   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83954   {
83955     try {
83956       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
83957     } catch (std::out_of_range& e) {
83958       {
83959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (std::exception& e) {
83962       {
83963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83964       };
83965     } catch (Dali::DaliException e) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83968       };
83969     } catch (...) {
83970       {
83971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83972       };
83973     }
83974   }
83975
83976   jresult = result;
83977   return jresult;
83978 }
83979
83980
83981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
83982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83983   Dali::Actor arg2 ;
83984   Dali::Actor *argp2 ;
83985
83986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83987   argp2 = (Dali::Actor *)jarg2;
83988   if (!argp2) {
83989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83990     return ;
83991   }
83992   arg2 = *argp2;
83993   {
83994     try {
83995       (arg1)->SetFocusIndicatorActor(arg2);
83996     } catch (std::out_of_range& e) {
83997       {
83998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83999       };
84000     } catch (std::exception& e) {
84001       {
84002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84003       };
84004     } catch (Dali::DaliException e) {
84005       {
84006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84007       };
84008     } catch (...) {
84009       {
84010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84011       };
84012     }
84013   }
84014
84015 }
84016
84017
84018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84019   void * jresult ;
84020   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84021   Dali::Actor result;
84022
84023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84024   {
84025     try {
84026       result = (arg1)->GetFocusIndicatorActor();
84027     } catch (std::out_of_range& e) {
84028       {
84029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84030       };
84031     } catch (std::exception& e) {
84032       {
84033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84034       };
84035     } catch (Dali::DaliException e) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84038       };
84039     } catch (...) {
84040       {
84041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84042       };
84043     }
84044   }
84045
84046   jresult = new Dali::Actor((const Dali::Actor &)result);
84047   return jresult;
84048 }
84049
84050
84051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84052   void * jresult ;
84053   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84054   Dali::Actor arg2 ;
84055   Dali::Actor *argp2 ;
84056   Dali::Actor result;
84057
84058   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84059   argp2 = (Dali::Actor *)jarg2;
84060   if (!argp2) {
84061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84062     return 0;
84063   }
84064   arg2 = *argp2;
84065   {
84066     try {
84067       result = (arg1)->GetFocusGroup(arg2);
84068     } catch (std::out_of_range& e) {
84069       {
84070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84071       };
84072     } catch (std::exception& e) {
84073       {
84074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84075       };
84076     } catch (Dali::DaliException e) {
84077       {
84078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84079       };
84080     } catch (...) {
84081       {
84082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84083       };
84084     }
84085   }
84086
84087   jresult = new Dali::Actor((const Dali::Actor &)result);
84088   return jresult;
84089 }
84090
84091
84092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84093   void * jresult ;
84094   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84095   Dali::Vector2 result;
84096
84097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84098   {
84099     try {
84100       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84101     } catch (std::out_of_range& e) {
84102       {
84103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84104       };
84105     } catch (std::exception& e) {
84106       {
84107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84108       };
84109     } catch (Dali::DaliException e) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84112       };
84113     } catch (...) {
84114       {
84115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84116       };
84117     }
84118   }
84119
84120   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84121   return jresult;
84122 }
84123
84124
84125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84126   void * jresult ;
84127   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84128   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84129
84130   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84131   {
84132     try {
84133       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84134     } catch (std::out_of_range& e) {
84135       {
84136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (std::exception& e) {
84139       {
84140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84141       };
84142     } catch (Dali::DaliException e) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84145       };
84146     } catch (...) {
84147       {
84148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84149       };
84150     }
84151   }
84152
84153   jresult = (void *)result;
84154   return jresult;
84155 }
84156
84157
84158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84159   void * jresult ;
84160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84161   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84162
84163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84164   {
84165     try {
84166       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84167     } catch (std::out_of_range& e) {
84168       {
84169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84170       };
84171     } catch (std::exception& e) {
84172       {
84173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84174       };
84175     } catch (Dali::DaliException e) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84178       };
84179     } catch (...) {
84180       {
84181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84182       };
84183     }
84184   }
84185
84186   jresult = (void *)result;
84187   return jresult;
84188 }
84189
84190
84191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84192   void * jresult ;
84193   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84194   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84195
84196   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84197   {
84198     try {
84199       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84200     } catch (std::out_of_range& e) {
84201       {
84202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84203       };
84204     } catch (std::exception& e) {
84205       {
84206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84207       };
84208     } catch (Dali::DaliException e) {
84209       {
84210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84211       };
84212     } catch (...) {
84213       {
84214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84215       };
84216     }
84217   }
84218
84219   jresult = (void *)result;
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84225   void * jresult ;
84226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84227   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84228
84229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84230   {
84231     try {
84232       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84233     } catch (std::out_of_range& e) {
84234       {
84235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (std::exception& e) {
84238       {
84239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84240       };
84241     } catch (Dali::DaliException e) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84244       };
84245     } catch (...) {
84246       {
84247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84248       };
84249     }
84250   }
84251
84252   jresult = (void *)result;
84253   return jresult;
84254 }
84255
84256
84257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84258   void * jresult ;
84259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84260   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84261
84262   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84263   {
84264     try {
84265       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84266     } catch (std::out_of_range& e) {
84267       {
84268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84269       };
84270     } catch (std::exception& e) {
84271       {
84272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84273       };
84274     } catch (Dali::DaliException e) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84277       };
84278     } catch (...) {
84279       {
84280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84281       };
84282     }
84283   }
84284
84285   jresult = (void *)result;
84286   return jresult;
84287 }
84288
84289
84290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84291   void * jresult ;
84292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84293   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84294
84295   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84296   {
84297     try {
84298       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84299     } catch (std::out_of_range& e) {
84300       {
84301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (std::exception& e) {
84304       {
84305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84306       };
84307     } catch (Dali::DaliException e) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84310       };
84311     } catch (...) {
84312       {
84313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84314       };
84315     }
84316   }
84317
84318   jresult = (void *)result;
84319   return jresult;
84320 }
84321
84322
84323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84324   void * jresult ;
84325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84326   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84327
84328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84329   {
84330     try {
84331       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84332     } catch (std::out_of_range& e) {
84333       {
84334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84335       };
84336     } catch (std::exception& e) {
84337       {
84338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84339       };
84340     } catch (Dali::DaliException e) {
84341       {
84342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84343       };
84344     } catch (...) {
84345       {
84346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84347       };
84348     }
84349   }
84350
84351   jresult = (void *)result;
84352   return jresult;
84353 }
84354
84355
84356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84357   void * jresult ;
84358   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84359   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84360
84361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84362   {
84363     try {
84364       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84365     } catch (std::out_of_range& e) {
84366       {
84367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84368       };
84369     } catch (std::exception& e) {
84370       {
84371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84372       };
84373     } catch (Dali::DaliException e) {
84374       {
84375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84376       };
84377     } catch (...) {
84378       {
84379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84380       };
84381     }
84382   }
84383
84384   jresult = (void *)result;
84385   return jresult;
84386 }
84387
84388
84389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84390   void * jresult ;
84391   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84392   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84393
84394   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84395   {
84396     try {
84397       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84398     } catch (std::out_of_range& e) {
84399       {
84400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84401       };
84402     } catch (std::exception& e) {
84403       {
84404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (Dali::DaliException e) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84409       };
84410     } catch (...) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84413       };
84414     }
84415   }
84416
84417   jresult = (void *)result;
84418   return jresult;
84419 }
84420
84421
84422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84423   void * jresult ;
84424   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84425   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84426
84427   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84428   {
84429     try {
84430       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84431     } catch (std::out_of_range& e) {
84432       {
84433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84434       };
84435     } catch (std::exception& e) {
84436       {
84437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84438       };
84439     } catch (Dali::DaliException e) {
84440       {
84441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84446       };
84447     }
84448   }
84449
84450   jresult = (void *)result;
84451   return jresult;
84452 }
84453
84454
84455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84456   void * jresult ;
84457   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84458   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84459
84460   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84461   {
84462     try {
84463       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84464     } catch (std::out_of_range& e) {
84465       {
84466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84467       };
84468     } catch (std::exception& e) {
84469       {
84470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84471       };
84472     } catch (Dali::DaliException e) {
84473       {
84474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84475       };
84476     } catch (...) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84479       };
84480     }
84481   }
84482
84483   jresult = (void *)result;
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84489   void * jresult ;
84490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84491   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84492
84493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84494   {
84495     try {
84496       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84497     } catch (std::out_of_range& e) {
84498       {
84499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84500       };
84501     } catch (std::exception& e) {
84502       {
84503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84504       };
84505     } catch (Dali::DaliException e) {
84506       {
84507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84508       };
84509     } catch (...) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84512       };
84513     }
84514   }
84515
84516   jresult = (void *)result;
84517   return jresult;
84518 }
84519
84520
84521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84522   void * jresult ;
84523   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84524   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84525
84526   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84527   {
84528     try {
84529       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84530     } catch (std::out_of_range& e) {
84531       {
84532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84533       };
84534     } catch (std::exception& e) {
84535       {
84536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84537       };
84538     } catch (Dali::DaliException e) {
84539       {
84540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84541       };
84542     } catch (...) {
84543       {
84544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84545       };
84546     }
84547   }
84548
84549   jresult = (void *)result;
84550   return jresult;
84551 }
84552
84553
84554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84555   void * jresult ;
84556   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84557   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84558
84559   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84560   {
84561     try {
84562       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84563     } catch (std::out_of_range& e) {
84564       {
84565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84566       };
84567     } catch (std::exception& e) {
84568       {
84569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84570       };
84571     } catch (Dali::DaliException e) {
84572       {
84573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84574       };
84575     } catch (...) {
84576       {
84577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84578       };
84579     }
84580   }
84581
84582   jresult = (void *)result;
84583   return jresult;
84584 }
84585
84586
84587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84588   void * jresult ;
84589   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84590   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84591
84592   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84593   {
84594     try {
84595       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84596     } catch (std::out_of_range& e) {
84597       {
84598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (std::exception& e) {
84601       {
84602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84603       };
84604     } catch (Dali::DaliException e) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84607       };
84608     } catch (...) {
84609       {
84610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84611       };
84612     }
84613   }
84614
84615   jresult = (void *)result;
84616   return jresult;
84617 }
84618
84619
84620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84621   void * jresult ;
84622   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84623   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84624
84625   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84626   {
84627     try {
84628       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84629     } catch (std::out_of_range& e) {
84630       {
84631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84632       };
84633     } catch (std::exception& e) {
84634       {
84635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84636       };
84637     } catch (Dali::DaliException e) {
84638       {
84639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84640       };
84641     } catch (...) {
84642       {
84643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84644       };
84645     }
84646   }
84647
84648   jresult = (void *)result;
84649   return jresult;
84650 }
84651
84652
84653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84654   void * jresult ;
84655   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84656   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84657
84658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84659   {
84660     try {
84661       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84662     } catch (std::out_of_range& e) {
84663       {
84664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84665       };
84666     } catch (std::exception& e) {
84667       {
84668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84669       };
84670     } catch (Dali::DaliException e) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84673       };
84674     } catch (...) {
84675       {
84676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84677       };
84678     }
84679   }
84680
84681   jresult = (void *)result;
84682   return jresult;
84683 }
84684
84685
84686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84687   void * jresult ;
84688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84689   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84690
84691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84692   {
84693     try {
84694       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84695     } catch (std::out_of_range& e) {
84696       {
84697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (std::exception& e) {
84700       {
84701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (Dali::DaliException e) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84706       };
84707     } catch (...) {
84708       {
84709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84710       };
84711     }
84712   }
84713
84714   jresult = (void *)result;
84715   return jresult;
84716 }
84717
84718
84719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84720   void * jresult ;
84721   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84722   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84723
84724   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84725   {
84726     try {
84727       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84728     } catch (std::out_of_range& e) {
84729       {
84730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84731       };
84732     } catch (std::exception& e) {
84733       {
84734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84735       };
84736     } catch (Dali::DaliException e) {
84737       {
84738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84739       };
84740     } catch (...) {
84741       {
84742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84743       };
84744     }
84745   }
84746
84747   jresult = (void *)result;
84748   return jresult;
84749 }
84750
84751
84752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84753   void * jresult ;
84754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84755   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84756
84757   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84758   {
84759     try {
84760       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84761     } catch (std::out_of_range& e) {
84762       {
84763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84764       };
84765     } catch (std::exception& e) {
84766       {
84767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84768       };
84769     } catch (Dali::DaliException e) {
84770       {
84771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84772       };
84773     } catch (...) {
84774       {
84775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84776       };
84777     }
84778   }
84779
84780   jresult = (void *)result;
84781   return jresult;
84782 }
84783
84784
84785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84786   void * jresult ;
84787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84789
84790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84791   {
84792     try {
84793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84794     } catch (std::out_of_range& e) {
84795       {
84796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84797       };
84798     } catch (std::exception& e) {
84799       {
84800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84801       };
84802     } catch (Dali::DaliException e) {
84803       {
84804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84805       };
84806     } catch (...) {
84807       {
84808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84809       };
84810     }
84811   }
84812
84813   jresult = (void *)result;
84814   return jresult;
84815 }
84816
84817
84818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84819   void * jresult ;
84820   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84821   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84822
84823   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84824   {
84825     try {
84826       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84827     } catch (std::out_of_range& e) {
84828       {
84829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84830       };
84831     } catch (std::exception& e) {
84832       {
84833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84834       };
84835     } catch (Dali::DaliException e) {
84836       {
84837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84838       };
84839     } catch (...) {
84840       {
84841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84842       };
84843     }
84844   }
84845
84846   jresult = (void *)result;
84847   return jresult;
84848 }
84849
84850
84851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84852   void * jresult ;
84853   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84854   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84855
84856   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84857   {
84858     try {
84859       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84860     } catch (std::out_of_range& e) {
84861       {
84862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84863       };
84864     } catch (std::exception& e) {
84865       {
84866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84867       };
84868     } catch (Dali::DaliException e) {
84869       {
84870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84871       };
84872     } catch (...) {
84873       {
84874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84875       };
84876     }
84877   }
84878
84879   jresult = (void *)result;
84880   return jresult;
84881 }
84882
84883
84884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84885   void * jresult ;
84886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84887   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84888
84889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84890   {
84891     try {
84892       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84893     } catch (std::out_of_range& e) {
84894       {
84895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84896       };
84897     } catch (std::exception& e) {
84898       {
84899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84900       };
84901     } catch (Dali::DaliException e) {
84902       {
84903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84904       };
84905     } catch (...) {
84906       {
84907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84908       };
84909     }
84910   }
84911
84912   jresult = (void *)result;
84913   return jresult;
84914 }
84915
84916
84917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84918   void * jresult ;
84919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84920   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84921
84922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84923   {
84924     try {
84925       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
84926     } catch (std::out_of_range& e) {
84927       {
84928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84929       };
84930     } catch (std::exception& e) {
84931       {
84932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84933       };
84934     } catch (Dali::DaliException e) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84937       };
84938     } catch (...) {
84939       {
84940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84941       };
84942     }
84943   }
84944
84945   jresult = (void *)result;
84946   return jresult;
84947 }
84948
84949
84950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
84951   void * jresult ;
84952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84953   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84954
84955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84956   {
84957     try {
84958       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
84959     } catch (std::out_of_range& e) {
84960       {
84961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (std::exception& e) {
84964       {
84965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (Dali::DaliException e) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84970       };
84971     } catch (...) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84974       };
84975     }
84976   }
84977
84978   jresult = (void *)result;
84979   return jresult;
84980 }
84981
84982
84983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
84984   void * jresult ;
84985   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84986   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84987
84988   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84989   {
84990     try {
84991       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
84992     } catch (std::out_of_range& e) {
84993       {
84994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (std::exception& e) {
84997       {
84998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84999       };
85000     } catch (Dali::DaliException e) {
85001       {
85002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85003       };
85004     } catch (...) {
85005       {
85006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85007       };
85008     }
85009   }
85010
85011   jresult = (void *)result;
85012   return jresult;
85013 }
85014
85015
85016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85017   void * jresult ;
85018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85019   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85020
85021   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85022   {
85023     try {
85024       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85025     } catch (std::out_of_range& e) {
85026       {
85027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85028       };
85029     } catch (std::exception& e) {
85030       {
85031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85032       };
85033     } catch (Dali::DaliException e) {
85034       {
85035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85036       };
85037     } catch (...) {
85038       {
85039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85040       };
85041     }
85042   }
85043
85044   jresult = (void *)result;
85045   return jresult;
85046 }
85047
85048
85049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85050   void * jresult ;
85051   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85052   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85053
85054   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85055   {
85056     try {
85057       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85058     } catch (std::out_of_range& e) {
85059       {
85060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85061       };
85062     } catch (std::exception& e) {
85063       {
85064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85065       };
85066     } catch (Dali::DaliException e) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85069       };
85070     } catch (...) {
85071       {
85072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85073       };
85074     }
85075   }
85076
85077   jresult = (void *)result;
85078   return jresult;
85079 }
85080
85081
85082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85083   void * jresult ;
85084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85085   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85086
85087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85088   {
85089     try {
85090       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85091     } catch (std::out_of_range& e) {
85092       {
85093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (std::exception& e) {
85096       {
85097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (Dali::DaliException e) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85102       };
85103     } catch (...) {
85104       {
85105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85106       };
85107     }
85108   }
85109
85110   jresult = (void *)result;
85111   return jresult;
85112 }
85113
85114
85115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85116   void * jresult ;
85117   Dali::Toolkit::StyleManager *result = 0 ;
85118
85119   {
85120     try {
85121       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85122     } catch (std::out_of_range& e) {
85123       {
85124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (std::exception& e) {
85127       {
85128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85129       };
85130     } catch (Dali::DaliException e) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85133       };
85134     } catch (...) {
85135       {
85136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85137       };
85138     }
85139   }
85140
85141   jresult = (void *)result;
85142   return jresult;
85143 }
85144
85145
85146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85147   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85148
85149   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85150   {
85151     try {
85152       delete arg1;
85153     } catch (std::out_of_range& e) {
85154       {
85155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85156       };
85157     } catch (std::exception& e) {
85158       {
85159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85160       };
85161     } catch (Dali::DaliException e) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85164       };
85165     } catch (...) {
85166       {
85167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85168       };
85169     }
85170   }
85171
85172 }
85173
85174
85175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85176   void * jresult ;
85177   Dali::Toolkit::StyleManager result;
85178
85179   {
85180     try {
85181       result = Dali::Toolkit::StyleManager::Get();
85182     } catch (std::out_of_range& e) {
85183       {
85184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85185       };
85186     } catch (std::exception& e) {
85187       {
85188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85189       };
85190     } catch (Dali::DaliException e) {
85191       {
85192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85193       };
85194     } catch (...) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85197       };
85198     }
85199   }
85200
85201   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85202   return jresult;
85203 }
85204
85205
85206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85207   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85208   std::string *arg2 = 0 ;
85209
85210   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85211   if (!jarg2) {
85212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85213     return ;
85214   }
85215   std::string arg2_str(jarg2);
85216   arg2 = &arg2_str;
85217   {
85218     try {
85219       (arg1)->ApplyTheme((std::string const &)*arg2);
85220     } catch (std::out_of_range& e) {
85221       {
85222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85223       };
85224     } catch (std::exception& e) {
85225       {
85226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85227       };
85228     } catch (Dali::DaliException e) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85231       };
85232     } catch (...) {
85233       {
85234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85235       };
85236     }
85237   }
85238
85239
85240   //argout typemap for const std::string&
85241
85242 }
85243
85244
85245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85246   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85247
85248   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85249   {
85250     try {
85251       (arg1)->ApplyDefaultTheme();
85252     } catch (std::out_of_range& e) {
85253       {
85254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85255       };
85256     } catch (std::exception& e) {
85257       {
85258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85259       };
85260     } catch (Dali::DaliException e) {
85261       {
85262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85263       };
85264     } catch (...) {
85265       {
85266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85267       };
85268     }
85269   }
85270
85271 }
85272
85273
85274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85275   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85276   std::string *arg2 = 0 ;
85277   Dali::Property::Value *arg3 = 0 ;
85278
85279   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85280   if (!jarg2) {
85281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85282     return ;
85283   }
85284   std::string arg2_str(jarg2);
85285   arg2 = &arg2_str;
85286   arg3 = (Dali::Property::Value *)jarg3;
85287   if (!arg3) {
85288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85289     return ;
85290   }
85291   {
85292     try {
85293       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85294     } catch (std::out_of_range& e) {
85295       {
85296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85297       };
85298     } catch (std::exception& e) {
85299       {
85300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85301       };
85302     } catch (Dali::DaliException e) {
85303       {
85304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85305       };
85306     } catch (...) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85309       };
85310     }
85311   }
85312
85313
85314   //argout typemap for const std::string&
85315
85316 }
85317
85318
85319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85320   unsigned int jresult ;
85321   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85322   std::string *arg2 = 0 ;
85323   Dali::Property::Value *arg3 = 0 ;
85324   bool result;
85325
85326   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85327   if (!jarg2) {
85328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85329     return 0;
85330   }
85331   std::string arg2_str(jarg2);
85332   arg2 = &arg2_str;
85333   arg3 = (Dali::Property::Value *)jarg3;
85334   if (!arg3) {
85335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85336     return 0;
85337   }
85338   {
85339     try {
85340       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85341     } catch (std::out_of_range& e) {
85342       {
85343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85344       };
85345     } catch (std::exception& e) {
85346       {
85347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85348       };
85349     } catch (Dali::DaliException e) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85352       };
85353     } catch (...) {
85354       {
85355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85356       };
85357     }
85358   }
85359
85360   jresult = result;
85361
85362   //argout typemap for const std::string&
85363
85364   return jresult;
85365 }
85366
85367
85368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85369   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85370   Dali::Toolkit::Control arg2 ;
85371   std::string *arg3 = 0 ;
85372   std::string *arg4 = 0 ;
85373   Dali::Toolkit::Control *argp2 ;
85374
85375   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85376   argp2 = (Dali::Toolkit::Control *)jarg2;
85377   if (!argp2) {
85378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85379     return ;
85380   }
85381   arg2 = *argp2;
85382   if (!jarg3) {
85383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85384     return ;
85385   }
85386   std::string arg3_str(jarg3);
85387   arg3 = &arg3_str;
85388   if (!jarg4) {
85389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85390     return ;
85391   }
85392   std::string arg4_str(jarg4);
85393   arg4 = &arg4_str;
85394   {
85395     try {
85396       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85397     } catch (std::out_of_range& e) {
85398       {
85399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85400       };
85401     } catch (std::exception& e) {
85402       {
85403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85404       };
85405     } catch (Dali::DaliException e) {
85406       {
85407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85408       };
85409     } catch (...) {
85410       {
85411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85412       };
85413     }
85414   }
85415
85416
85417   //argout typemap for const std::string&
85418
85419
85420   //argout typemap for const std::string&
85421
85422 }
85423
85424
85425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85426   void * jresult ;
85427   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85428   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85429
85430   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85431   {
85432     try {
85433       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85434     } catch (std::out_of_range& e) {
85435       {
85436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (std::exception& e) {
85439       {
85440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85441       };
85442     } catch (Dali::DaliException e) {
85443       {
85444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85445       };
85446     } catch (...) {
85447       {
85448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85449       };
85450     }
85451   }
85452
85453   jresult = (void *)result;
85454   return jresult;
85455 }
85456
85457
85458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85459   int jresult ;
85460   int result;
85461
85462   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85463   jresult = (int)result;
85464   return jresult;
85465 }
85466
85467
85468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85469   int jresult ;
85470   int result;
85471
85472   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85473   jresult = (int)result;
85474   return jresult;
85475 }
85476
85477
85478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85479   int jresult ;
85480   int result;
85481
85482   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85483   jresult = (int)result;
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85489   int jresult ;
85490   int result;
85491
85492   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85493   jresult = (int)result;
85494   return jresult;
85495 }
85496
85497
85498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85499   int jresult ;
85500   int result;
85501
85502   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85503   jresult = (int)result;
85504   return jresult;
85505 }
85506
85507
85508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85509   int jresult ;
85510   int result;
85511
85512   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85513   jresult = (int)result;
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85519   int jresult ;
85520   int result;
85521
85522   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85523   jresult = (int)result;
85524   return jresult;
85525 }
85526
85527
85528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85529   int jresult ;
85530   int result;
85531
85532   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85533   jresult = (int)result;
85534   return jresult;
85535 }
85536
85537
85538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85539   int jresult ;
85540   int result;
85541
85542   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85543   jresult = (int)result;
85544   return jresult;
85545 }
85546
85547
85548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85549   int jresult ;
85550   int result;
85551
85552   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85553   jresult = (int)result;
85554   return jresult;
85555 }
85556
85557
85558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85559   int jresult ;
85560   int result;
85561
85562   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85563   jresult = (int)result;
85564   return jresult;
85565 }
85566
85567
85568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85569   int jresult ;
85570   int result;
85571
85572   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85573   jresult = (int)result;
85574   return jresult;
85575 }
85576
85577
85578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85579   int jresult ;
85580   int result;
85581
85582   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85583   jresult = (int)result;
85584   return jresult;
85585 }
85586
85587
85588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85589   int jresult ;
85590   int result;
85591
85592   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85593   jresult = (int)result;
85594   return jresult;
85595 }
85596
85597
85598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85599   int jresult ;
85600   int result;
85601
85602   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85603   jresult = (int)result;
85604   return jresult;
85605 }
85606
85607
85608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85609   void * jresult ;
85610   Dali::Toolkit::Slider::Property *result = 0 ;
85611
85612   {
85613     try {
85614       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85615     } catch (std::out_of_range& e) {
85616       {
85617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85618       };
85619     } catch (std::exception& e) {
85620       {
85621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (Dali::DaliException e) {
85624       {
85625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85626       };
85627     } catch (...) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85630       };
85631     }
85632   }
85633
85634   jresult = (void *)result;
85635   return jresult;
85636 }
85637
85638
85639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85640   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85641
85642   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85643   {
85644     try {
85645       delete arg1;
85646     } catch (std::out_of_range& e) {
85647       {
85648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85649       };
85650     } catch (std::exception& e) {
85651       {
85652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85653       };
85654     } catch (Dali::DaliException e) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85657       };
85658     } catch (...) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85661       };
85662     }
85663   }
85664
85665 }
85666
85667
85668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85669   void * jresult ;
85670   Dali::Toolkit::Slider result;
85671
85672   {
85673     try {
85674       result = Dali::Toolkit::Slider::New();
85675     } catch (std::out_of_range& e) {
85676       {
85677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85678       };
85679     } catch (std::exception& e) {
85680       {
85681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85682       };
85683     } catch (Dali::DaliException e) {
85684       {
85685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85686       };
85687     } catch (...) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85690       };
85691     }
85692   }
85693
85694   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85695   return jresult;
85696 }
85697
85698
85699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85700   void * jresult ;
85701   Dali::Toolkit::Slider *result = 0 ;
85702
85703   {
85704     try {
85705       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85706     } catch (std::out_of_range& e) {
85707       {
85708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85709       };
85710     } catch (std::exception& e) {
85711       {
85712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85713       };
85714     } catch (Dali::DaliException e) {
85715       {
85716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85717       };
85718     } catch (...) {
85719       {
85720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85721       };
85722     }
85723   }
85724
85725   jresult = (void *)result;
85726   return jresult;
85727 }
85728
85729
85730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85731   void * jresult ;
85732   Dali::Toolkit::Slider *arg1 = 0 ;
85733   Dali::Toolkit::Slider *result = 0 ;
85734
85735   arg1 = (Dali::Toolkit::Slider *)jarg1;
85736   if (!arg1) {
85737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85738     return 0;
85739   }
85740   {
85741     try {
85742       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85743     } catch (std::out_of_range& e) {
85744       {
85745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85746       };
85747     } catch (std::exception& e) {
85748       {
85749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85750       };
85751     } catch (Dali::DaliException e) {
85752       {
85753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85754       };
85755     } catch (...) {
85756       {
85757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85758       };
85759     }
85760   }
85761
85762   jresult = (void *)result;
85763   return jresult;
85764 }
85765
85766
85767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85768   void * jresult ;
85769   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85770   Dali::Toolkit::Slider *arg2 = 0 ;
85771   Dali::Toolkit::Slider *result = 0 ;
85772
85773   arg1 = (Dali::Toolkit::Slider *)jarg1;
85774   arg2 = (Dali::Toolkit::Slider *)jarg2;
85775   if (!arg2) {
85776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85777     return 0;
85778   }
85779   {
85780     try {
85781       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85782     } catch (std::out_of_range& e) {
85783       {
85784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (std::exception& e) {
85787       {
85788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (Dali::DaliException e) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85793       };
85794     } catch (...) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85797       };
85798     }
85799   }
85800
85801   jresult = (void *)result;
85802   return jresult;
85803 }
85804
85805
85806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85807   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85808
85809   arg1 = (Dali::Toolkit::Slider *)jarg1;
85810   {
85811     try {
85812       delete arg1;
85813     } catch (std::out_of_range& e) {
85814       {
85815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85816       };
85817     } catch (std::exception& e) {
85818       {
85819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85820       };
85821     } catch (Dali::DaliException e) {
85822       {
85823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85824       };
85825     } catch (...) {
85826       {
85827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85828       };
85829     }
85830   }
85831
85832 }
85833
85834
85835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85836   void * jresult ;
85837   Dali::BaseHandle arg1 ;
85838   Dali::BaseHandle *argp1 ;
85839   Dali::Toolkit::Slider result;
85840
85841   argp1 = (Dali::BaseHandle *)jarg1;
85842   if (!argp1) {
85843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85844     return 0;
85845   }
85846   arg1 = *argp1;
85847   {
85848     try {
85849       result = Dali::Toolkit::Slider::DownCast(arg1);
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (Dali::DaliException e) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85861       };
85862     } catch (...) {
85863       {
85864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85865       };
85866     }
85867   }
85868
85869   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85870   return jresult;
85871 }
85872
85873
85874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85875   void * jresult ;
85876   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85877   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85878
85879   arg1 = (Dali::Toolkit::Slider *)jarg1;
85880   {
85881     try {
85882       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (Dali::DaliException e) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901
85902   jresult = (void *)result;
85903   return jresult;
85904 }
85905
85906
85907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85908   void * jresult ;
85909   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85910   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85911
85912   arg1 = (Dali::Toolkit::Slider *)jarg1;
85913   {
85914     try {
85915       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85916     } catch (std::out_of_range& e) {
85917       {
85918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85919       };
85920     } catch (std::exception& e) {
85921       {
85922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (Dali::DaliException e) {
85925       {
85926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85927       };
85928     } catch (...) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85931       };
85932     }
85933   }
85934
85935   jresult = (void *)result;
85936   return jresult;
85937 }
85938
85939
85940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
85941   void * jresult ;
85942   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85943   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
85944
85945   arg1 = (Dali::Toolkit::Slider *)jarg1;
85946   {
85947     try {
85948       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
85949     } catch (std::out_of_range& e) {
85950       {
85951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (std::exception& e) {
85954       {
85955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (Dali::DaliException e) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85960       };
85961     } catch (...) {
85962       {
85963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85964       };
85965     }
85966   }
85967
85968   jresult = (void *)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
85974   int jresult ;
85975   int result;
85976
85977   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
85978   jresult = (int)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
85984   int jresult ;
85985   int result;
85986
85987   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
85988   jresult = (int)result;
85989   return jresult;
85990 }
85991
85992
85993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
85994   int jresult ;
85995   int result;
85996
85997   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
85998   jresult = (int)result;
85999   return jresult;
86000 }
86001
86002
86003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86004   int jresult ;
86005   int result;
86006
86007   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86008   jresult = (int)result;
86009   return jresult;
86010 }
86011
86012
86013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86014   int result;
86015
86016   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86017
86018   return result;
86019 }
86020
86021
86022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86023   void * jresult ;
86024   Dali::Toolkit::VideoView::Property *result = 0 ;
86025
86026   {
86027     try {
86028       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86029     } catch (std::out_of_range& e) {
86030       {
86031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86032       };
86033     } catch (std::exception& e) {
86034       {
86035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86036       };
86037     } catch (Dali::DaliException e) {
86038       {
86039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86040       };
86041     } catch (...) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86044       };
86045     }
86046   }
86047
86048   jresult = (void *)result;
86049   return jresult;
86050 }
86051
86052
86053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86054   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86055
86056   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86057   {
86058     try {
86059       delete arg1;
86060     } catch (std::out_of_range& e) {
86061       {
86062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86063       };
86064     } catch (std::exception& e) {
86065       {
86066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86067       };
86068     } catch (Dali::DaliException e) {
86069       {
86070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86071       };
86072     } catch (...) {
86073       {
86074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86075       };
86076     }
86077   }
86078
86079 }
86080
86081
86082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86083   void * jresult ;
86084   Dali::Toolkit::VideoView result;
86085
86086   {
86087     try {
86088       result = Dali::Toolkit::VideoView::New();
86089     } catch (std::out_of_range& e) {
86090       {
86091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86092       };
86093     } catch (std::exception& e) {
86094       {
86095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86096       };
86097     } catch (Dali::DaliException e) {
86098       {
86099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86100       };
86101     } catch (...) {
86102       {
86103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86104       };
86105     }
86106   }
86107
86108   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86109   return jresult;
86110 }
86111
86112
86113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86114   void * jresult ;
86115   std::string *arg1 = 0 ;
86116   Dali::Toolkit::VideoView result;
86117
86118   if (!jarg1) {
86119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86120     return 0;
86121   }
86122   std::string arg1_str(jarg1);
86123   arg1 = &arg1_str;
86124   {
86125     try {
86126       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86127     } catch (std::out_of_range& e) {
86128       {
86129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86130       };
86131     } catch (std::exception& e) {
86132       {
86133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86134       };
86135     } catch (Dali::DaliException e) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86138       };
86139     } catch (...) {
86140       {
86141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86142       };
86143     }
86144   }
86145
86146   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86147
86148   //argout typemap for const std::string&
86149
86150   return jresult;
86151 }
86152
86153
86154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86155   void * jresult ;
86156   Dali::Toolkit::VideoView *result = 0 ;
86157
86158   {
86159     try {
86160       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86161     } catch (std::out_of_range& e) {
86162       {
86163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86164       };
86165     } catch (std::exception& e) {
86166       {
86167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86168       };
86169     } catch (Dali::DaliException e) {
86170       {
86171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86172       };
86173     } catch (...) {
86174       {
86175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86176       };
86177     }
86178   }
86179
86180   jresult = (void *)result;
86181   return jresult;
86182 }
86183
86184
86185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86186   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86187
86188   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86189   {
86190     try {
86191       delete arg1;
86192     } catch (std::out_of_range& e) {
86193       {
86194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86195       };
86196     } catch (std::exception& e) {
86197       {
86198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86199       };
86200     } catch (Dali::DaliException e) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86203       };
86204     } catch (...) {
86205       {
86206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86207       };
86208     }
86209   }
86210
86211 }
86212
86213
86214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86215   void * jresult ;
86216   Dali::Toolkit::VideoView *arg1 = 0 ;
86217   Dali::Toolkit::VideoView *result = 0 ;
86218
86219   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86220   if (!arg1) {
86221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86222     return 0;
86223   }
86224   {
86225     try {
86226       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86227     } catch (std::out_of_range& e) {
86228       {
86229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86230       };
86231     } catch (std::exception& e) {
86232       {
86233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86234       };
86235     } catch (Dali::DaliException e) {
86236       {
86237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86238       };
86239     } catch (...) {
86240       {
86241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86242       };
86243     }
86244   }
86245
86246   jresult = (void *)result;
86247   return jresult;
86248 }
86249
86250
86251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86252   void * jresult ;
86253   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86254   Dali::Toolkit::VideoView *arg2 = 0 ;
86255   Dali::Toolkit::VideoView *result = 0 ;
86256
86257   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86258   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86259   if (!arg2) {
86260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86261     return 0;
86262   }
86263   {
86264     try {
86265       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86266     } catch (std::out_of_range& e) {
86267       {
86268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86269       };
86270     } catch (std::exception& e) {
86271       {
86272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86273       };
86274     } catch (Dali::DaliException e) {
86275       {
86276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86277       };
86278     } catch (...) {
86279       {
86280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86281       };
86282     }
86283   }
86284
86285   jresult = (void *)result;
86286   return jresult;
86287 }
86288
86289
86290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86291   void * jresult ;
86292   Dali::BaseHandle arg1 ;
86293   Dali::BaseHandle *argp1 ;
86294   Dali::Toolkit::VideoView result;
86295
86296   argp1 = (Dali::BaseHandle *)jarg1;
86297   if (!argp1) {
86298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86299     return 0;
86300   }
86301   arg1 = *argp1;
86302   {
86303     try {
86304       result = Dali::Toolkit::VideoView::DownCast(arg1);
86305     } catch (std::out_of_range& e) {
86306       {
86307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (std::exception& e) {
86310       {
86311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (Dali::DaliException e) {
86314       {
86315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86316       };
86317     } catch (...) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86320       };
86321     }
86322   }
86323
86324   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86325   return jresult;
86326 }
86327
86328
86329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86330   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86331
86332   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86333   {
86334     try {
86335       (arg1)->Play();
86336     } catch (std::out_of_range& e) {
86337       {
86338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86339       };
86340     } catch (std::exception& e) {
86341       {
86342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86343       };
86344     } catch (Dali::DaliException e) {
86345       {
86346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86347       };
86348     } catch (...) {
86349       {
86350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86351       };
86352     }
86353   }
86354
86355 }
86356
86357
86358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86359   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86360
86361   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86362   {
86363     try {
86364       (arg1)->Pause();
86365     } catch (std::out_of_range& e) {
86366       {
86367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86368       };
86369     } catch (std::exception& e) {
86370       {
86371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86372       };
86373     } catch (Dali::DaliException e) {
86374       {
86375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86376       };
86377     } catch (...) {
86378       {
86379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86380       };
86381     }
86382   }
86383
86384 }
86385
86386
86387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86388   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86389
86390   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86391   {
86392     try {
86393       (arg1)->Stop();
86394     } catch (std::out_of_range& e) {
86395       {
86396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86397       };
86398     } catch (std::exception& e) {
86399       {
86400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86401       };
86402     } catch (Dali::DaliException e) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86405       };
86406     } catch (...) {
86407       {
86408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86409       };
86410     }
86411   }
86412
86413 }
86414
86415
86416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86417   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86418   int arg2 ;
86419
86420   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86421   arg2 = (int)jarg2;
86422   {
86423     try {
86424       (arg1)->Forward(arg2);
86425     } catch (std::out_of_range& e) {
86426       {
86427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86428       };
86429     } catch (std::exception& e) {
86430       {
86431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86432       };
86433     } catch (Dali::DaliException e) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86436       };
86437     } catch (...) {
86438       {
86439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86440       };
86441     }
86442   }
86443
86444 }
86445
86446
86447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86448   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86449   int arg2 ;
86450
86451   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86452   arg2 = (int)jarg2;
86453   {
86454     try {
86455       (arg1)->Backward(arg2);
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86463       };
86464     } catch (Dali::DaliException e) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86467       };
86468     } catch (...) {
86469       {
86470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86471       };
86472     }
86473   }
86474
86475 }
86476
86477
86478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86479   void * jresult ;
86480   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86481   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86482
86483   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86484   {
86485     try {
86486       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86494       };
86495     } catch (Dali::DaliException e) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86498       };
86499     } catch (...) {
86500       {
86501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86502       };
86503     }
86504   }
86505
86506   jresult = (void *)result;
86507   return jresult;
86508 }
86509
86510
86511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86512   int jresult ;
86513   int result;
86514
86515   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86516   jresult = (int)result;
86517   return jresult;
86518 }
86519
86520
86521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86522   int jresult ;
86523   int result;
86524
86525   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86526   jresult = (int)result;
86527   return jresult;
86528 }
86529
86530
86531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86532   int jresult ;
86533   int result;
86534
86535   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86536   jresult = (int)result;
86537   return jresult;
86538 }
86539
86540
86541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86542   int jresult ;
86543   int result;
86544
86545   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86546   jresult = (int)result;
86547   return jresult;
86548 }
86549
86550
86551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86552   int jresult ;
86553   int result;
86554
86555   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86556   jresult = (int)result;
86557   return jresult;
86558 }
86559
86560
86561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86562   int jresult ;
86563   int result;
86564
86565   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86566   jresult = (int)result;
86567   return jresult;
86568 }
86569
86570
86571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86572   int jresult ;
86573   int result;
86574
86575   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86576   jresult = (int)result;
86577   return jresult;
86578 }
86579
86580
86581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86582   int jresult ;
86583   int result;
86584
86585   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86586   jresult = (int)result;
86587   return jresult;
86588 }
86589
86590
86591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86592   int jresult ;
86593   int result;
86594
86595   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86596   jresult = (int)result;
86597   return jresult;
86598 }
86599
86600
86601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86602   int jresult ;
86603   int result;
86604
86605   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86606   jresult = (int)result;
86607   return jresult;
86608 }
86609
86610
86611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86612   int jresult ;
86613   int result;
86614
86615   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86616   jresult = (int)result;
86617   return jresult;
86618 }
86619
86620
86621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86622   int jresult ;
86623   int result;
86624
86625   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86626   jresult = (int)result;
86627   return jresult;
86628 }
86629
86630
86631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86632   int jresult ;
86633   int result;
86634
86635   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86636   jresult = (int)result;
86637   return jresult;
86638 }
86639
86640
86641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86642   int jresult ;
86643   int result;
86644
86645   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86646   jresult = (int)result;
86647   return jresult;
86648 }
86649
86650
86651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86652   int jresult ;
86653   int result;
86654
86655   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86656   jresult = (int)result;
86657   return jresult;
86658 }
86659
86660
86661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86662   int jresult ;
86663   int result;
86664
86665   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86666   jresult = (int)result;
86667   return jresult;
86668 }
86669
86670
86671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86672   int jresult ;
86673   int result;
86674
86675   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86676   jresult = (int)result;
86677   return jresult;
86678 }
86679
86680
86681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86682   int jresult ;
86683   int result;
86684
86685   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86686   jresult = (int)result;
86687   return jresult;
86688 }
86689
86690
86691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86692   int jresult ;
86693   int result;
86694
86695   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86696   jresult = (int)result;
86697   return jresult;
86698 }
86699
86700
86701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86702   int jresult ;
86703   int result;
86704
86705   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86706   jresult = (int)result;
86707   return jresult;
86708 }
86709
86710
86711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86712   int jresult ;
86713   int result;
86714
86715   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86716   jresult = (int)result;
86717   return jresult;
86718 }
86719
86720
86721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86722   void * jresult ;
86723   Dali::Toolkit::Popup::Property *result = 0 ;
86724
86725   {
86726     try {
86727       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86728     } catch (std::out_of_range& e) {
86729       {
86730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (std::exception& e) {
86733       {
86734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86735       };
86736     } catch (Dali::DaliException e) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86739       };
86740     } catch (...) {
86741       {
86742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86743       };
86744     }
86745   }
86746
86747   jresult = (void *)result;
86748   return jresult;
86749 }
86750
86751
86752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86753   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86754
86755   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86756   {
86757     try {
86758       delete arg1;
86759     } catch (std::out_of_range& e) {
86760       {
86761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86762       };
86763     } catch (std::exception& e) {
86764       {
86765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86766       };
86767     } catch (Dali::DaliException e) {
86768       {
86769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86770       };
86771     } catch (...) {
86772       {
86773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86774       };
86775     }
86776   }
86777
86778 }
86779
86780
86781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86782   void * jresult ;
86783   Dali::Toolkit::Popup *result = 0 ;
86784
86785   {
86786     try {
86787       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86788     } catch (std::out_of_range& e) {
86789       {
86790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86791       };
86792     } catch (std::exception& e) {
86793       {
86794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86795       };
86796     } catch (Dali::DaliException e) {
86797       {
86798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86799       };
86800     } catch (...) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86803       };
86804     }
86805   }
86806
86807   jresult = (void *)result;
86808   return jresult;
86809 }
86810
86811
86812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86813   void * jresult ;
86814   Dali::Toolkit::Popup result;
86815
86816   {
86817     try {
86818       result = Dali::Toolkit::Popup::New();
86819     } catch (std::out_of_range& e) {
86820       {
86821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86822       };
86823     } catch (std::exception& e) {
86824       {
86825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86826       };
86827     } catch (Dali::DaliException e) {
86828       {
86829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86830       };
86831     } catch (...) {
86832       {
86833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86834       };
86835     }
86836   }
86837
86838   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86839   return jresult;
86840 }
86841
86842
86843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86844   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86845
86846   arg1 = (Dali::Toolkit::Popup *)jarg1;
86847   {
86848     try {
86849       delete arg1;
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86857       };
86858     } catch (Dali::DaliException e) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86865       };
86866     }
86867   }
86868
86869 }
86870
86871
86872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
86873   void * jresult ;
86874   Dali::Toolkit::Popup *arg1 = 0 ;
86875   Dali::Toolkit::Popup *result = 0 ;
86876
86877   arg1 = (Dali::Toolkit::Popup *)jarg1;
86878   if (!arg1) {
86879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86880     return 0;
86881   }
86882   {
86883     try {
86884       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
86885     } catch (std::out_of_range& e) {
86886       {
86887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (std::exception& e) {
86890       {
86891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86892       };
86893     } catch (Dali::DaliException e) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86896       };
86897     } catch (...) {
86898       {
86899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86900       };
86901     }
86902   }
86903
86904   jresult = (void *)result;
86905   return jresult;
86906 }
86907
86908
86909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
86910   void * jresult ;
86911   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86912   Dali::Toolkit::Popup *arg2 = 0 ;
86913   Dali::Toolkit::Popup *result = 0 ;
86914
86915   arg1 = (Dali::Toolkit::Popup *)jarg1;
86916   arg2 = (Dali::Toolkit::Popup *)jarg2;
86917   if (!arg2) {
86918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86919     return 0;
86920   }
86921   {
86922     try {
86923       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
86924     } catch (std::out_of_range& e) {
86925       {
86926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86927       };
86928     } catch (std::exception& e) {
86929       {
86930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86931       };
86932     } catch (Dali::DaliException e) {
86933       {
86934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86935       };
86936     } catch (...) {
86937       {
86938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86939       };
86940     }
86941   }
86942
86943   jresult = (void *)result;
86944   return jresult;
86945 }
86946
86947
86948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
86949   void * jresult ;
86950   Dali::BaseHandle arg1 ;
86951   Dali::BaseHandle *argp1 ;
86952   Dali::Toolkit::Popup result;
86953
86954   argp1 = (Dali::BaseHandle *)jarg1;
86955   if (!argp1) {
86956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86957     return 0;
86958   }
86959   arg1 = *argp1;
86960   {
86961     try {
86962       result = Dali::Toolkit::Popup::DownCast(arg1);
86963     } catch (std::out_of_range& e) {
86964       {
86965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86966       };
86967     } catch (std::exception& e) {
86968       {
86969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86970       };
86971     } catch (Dali::DaliException e) {
86972       {
86973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86974       };
86975     } catch (...) {
86976       {
86977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86978       };
86979     }
86980   }
86981
86982   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86983   return jresult;
86984 }
86985
86986
86987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
86988   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86989   Dali::Actor arg2 ;
86990   Dali::Actor *argp2 ;
86991
86992   arg1 = (Dali::Toolkit::Popup *)jarg1;
86993   argp2 = (Dali::Actor *)jarg2;
86994   if (!argp2) {
86995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86996     return ;
86997   }
86998   arg2 = *argp2;
86999   {
87000     try {
87001       (arg1)->SetTitle(arg2);
87002     } catch (std::out_of_range& e) {
87003       {
87004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87005       };
87006     } catch (std::exception& e) {
87007       {
87008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87009       };
87010     } catch (Dali::DaliException e) {
87011       {
87012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87013       };
87014     } catch (...) {
87015       {
87016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87017       };
87018     }
87019   }
87020
87021 }
87022
87023
87024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87025   void * jresult ;
87026   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87027   Dali::Actor result;
87028
87029   arg1 = (Dali::Toolkit::Popup *)jarg1;
87030   {
87031     try {
87032       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87033     } catch (std::out_of_range& e) {
87034       {
87035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87036       };
87037     } catch (std::exception& e) {
87038       {
87039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87040       };
87041     } catch (Dali::DaliException e) {
87042       {
87043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87048       };
87049     }
87050   }
87051
87052   jresult = new Dali::Actor((const Dali::Actor &)result);
87053   return jresult;
87054 }
87055
87056
87057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87058   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87059   Dali::Actor arg2 ;
87060   Dali::Actor *argp2 ;
87061
87062   arg1 = (Dali::Toolkit::Popup *)jarg1;
87063   argp2 = (Dali::Actor *)jarg2;
87064   if (!argp2) {
87065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87066     return ;
87067   }
87068   arg2 = *argp2;
87069   {
87070     try {
87071       (arg1)->SetContent(arg2);
87072     } catch (std::out_of_range& e) {
87073       {
87074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87075       };
87076     } catch (std::exception& e) {
87077       {
87078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87079       };
87080     } catch (Dali::DaliException e) {
87081       {
87082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87083       };
87084     } catch (...) {
87085       {
87086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87087       };
87088     }
87089   }
87090
87091 }
87092
87093
87094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87095   void * jresult ;
87096   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87097   Dali::Actor result;
87098
87099   arg1 = (Dali::Toolkit::Popup *)jarg1;
87100   {
87101     try {
87102       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87103     } catch (std::out_of_range& e) {
87104       {
87105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (std::exception& e) {
87108       {
87109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (Dali::DaliException e) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87114       };
87115     } catch (...) {
87116       {
87117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87118       };
87119     }
87120   }
87121
87122   jresult = new Dali::Actor((const Dali::Actor &)result);
87123   return jresult;
87124 }
87125
87126
87127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87128   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87129   Dali::Actor arg2 ;
87130   Dali::Actor *argp2 ;
87131
87132   arg1 = (Dali::Toolkit::Popup *)jarg1;
87133   argp2 = (Dali::Actor *)jarg2;
87134   if (!argp2) {
87135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87136     return ;
87137   }
87138   arg2 = *argp2;
87139   {
87140     try {
87141       (arg1)->SetFooter(arg2);
87142     } catch (std::out_of_range& e) {
87143       {
87144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87145       };
87146     } catch (std::exception& e) {
87147       {
87148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87149       };
87150     } catch (Dali::DaliException e) {
87151       {
87152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87153       };
87154     } catch (...) {
87155       {
87156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87157       };
87158     }
87159   }
87160
87161 }
87162
87163
87164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87165   void * jresult ;
87166   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87167   Dali::Actor result;
87168
87169   arg1 = (Dali::Toolkit::Popup *)jarg1;
87170   {
87171     try {
87172       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87173     } catch (std::out_of_range& e) {
87174       {
87175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87176       };
87177     } catch (std::exception& e) {
87178       {
87179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87180       };
87181     } catch (Dali::DaliException e) {
87182       {
87183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87184       };
87185     } catch (...) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87188       };
87189     }
87190   }
87191
87192   jresult = new Dali::Actor((const Dali::Actor &)result);
87193   return jresult;
87194 }
87195
87196
87197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87198   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87199   Dali::Toolkit::Popup::DisplayState arg2 ;
87200
87201   arg1 = (Dali::Toolkit::Popup *)jarg1;
87202   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87203   {
87204     try {
87205       (arg1)->SetDisplayState(arg2);
87206     } catch (std::out_of_range& e) {
87207       {
87208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87209       };
87210     } catch (std::exception& e) {
87211       {
87212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87213       };
87214     } catch (Dali::DaliException e) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87217       };
87218     } catch (...) {
87219       {
87220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87221       };
87222     }
87223   }
87224
87225 }
87226
87227
87228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87229   int jresult ;
87230   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87231   Dali::Toolkit::Popup::DisplayState result;
87232
87233   arg1 = (Dali::Toolkit::Popup *)jarg1;
87234   {
87235     try {
87236       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87237     } catch (std::out_of_range& e) {
87238       {
87239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87240       };
87241     } catch (std::exception& e) {
87242       {
87243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (Dali::DaliException e) {
87246       {
87247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87248       };
87249     } catch (...) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87252       };
87253     }
87254   }
87255
87256   jresult = (int)result;
87257   return jresult;
87258 }
87259
87260
87261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87262   void * jresult ;
87263   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87264   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87265
87266   arg1 = (Dali::Toolkit::Popup *)jarg1;
87267   {
87268     try {
87269       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87270     } catch (std::out_of_range& e) {
87271       {
87272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87273       };
87274     } catch (std::exception& e) {
87275       {
87276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87277       };
87278     } catch (Dali::DaliException e) {
87279       {
87280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87281       };
87282     } catch (...) {
87283       {
87284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87285       };
87286     }
87287   }
87288
87289   jresult = (void *)result;
87290   return jresult;
87291 }
87292
87293
87294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87295   void * jresult ;
87296   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87297   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87298
87299   arg1 = (Dali::Toolkit::Popup *)jarg1;
87300   {
87301     try {
87302       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87303     } catch (std::out_of_range& e) {
87304       {
87305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87306       };
87307     } catch (std::exception& e) {
87308       {
87309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87310       };
87311     } catch (Dali::DaliException e) {
87312       {
87313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87314       };
87315     } catch (...) {
87316       {
87317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87318       };
87319     }
87320   }
87321
87322   jresult = (void *)result;
87323   return jresult;
87324 }
87325
87326
87327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87328   void * jresult ;
87329   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87330   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87331
87332   arg1 = (Dali::Toolkit::Popup *)jarg1;
87333   {
87334     try {
87335       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87336     } catch (std::out_of_range& e) {
87337       {
87338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87339       };
87340     } catch (std::exception& e) {
87341       {
87342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87343       };
87344     } catch (Dali::DaliException e) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87347       };
87348     } catch (...) {
87349       {
87350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87351       };
87352     }
87353   }
87354
87355   jresult = (void *)result;
87356   return jresult;
87357 }
87358
87359
87360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87361   void * jresult ;
87362   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87363   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87364
87365   arg1 = (Dali::Toolkit::Popup *)jarg1;
87366   {
87367     try {
87368       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87384       };
87385     }
87386   }
87387
87388   jresult = (void *)result;
87389   return jresult;
87390 }
87391
87392
87393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87394   void * jresult ;
87395   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87396   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87397
87398   arg1 = (Dali::Toolkit::Popup *)jarg1;
87399   {
87400     try {
87401       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87402     } catch (std::out_of_range& e) {
87403       {
87404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87405       };
87406     } catch (std::exception& e) {
87407       {
87408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87409       };
87410     } catch (Dali::DaliException e) {
87411       {
87412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87413       };
87414     } catch (...) {
87415       {
87416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87417       };
87418     }
87419   }
87420
87421   jresult = (void *)result;
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87427   int jresult ;
87428   int result;
87429
87430   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87431   jresult = (int)result;
87432   return jresult;
87433 }
87434
87435
87436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87437   int jresult ;
87438   int result;
87439
87440   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87441   jresult = (int)result;
87442   return jresult;
87443 }
87444
87445
87446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87447   int jresult ;
87448   int result;
87449
87450   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87451   jresult = (int)result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87457   int jresult ;
87458   int result;
87459
87460   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87461   jresult = (int)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87467   int jresult ;
87468   int result;
87469
87470   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87471   jresult = (int)result;
87472   return jresult;
87473 }
87474
87475
87476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87477   int jresult ;
87478   int result;
87479
87480   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87481   jresult = (int)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87487   int jresult ;
87488   int result;
87489
87490   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87491   jresult = (int)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87497   int jresult ;
87498   int result;
87499
87500   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87501   jresult = (int)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87507   int jresult ;
87508   int result;
87509
87510   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87511   jresult = (int)result;
87512   return jresult;
87513 }
87514
87515
87516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87517   void * jresult ;
87518   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87519
87520   {
87521     try {
87522       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87523     } catch (std::out_of_range& e) {
87524       {
87525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87526       };
87527     } catch (std::exception& e) {
87528       {
87529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87530       };
87531     } catch (Dali::DaliException e) {
87532       {
87533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87534       };
87535     } catch (...) {
87536       {
87537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87538       };
87539     }
87540   }
87541
87542   jresult = (void *)result;
87543   return jresult;
87544 }
87545
87546
87547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87548   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87549
87550   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87551   {
87552     try {
87553       delete arg1;
87554     } catch (std::out_of_range& e) {
87555       {
87556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87557       };
87558     } catch (std::exception& e) {
87559       {
87560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87561       };
87562     } catch (Dali::DaliException e) {
87563       {
87564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87565       };
87566     } catch (...) {
87567       {
87568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87569       };
87570     }
87571   }
87572
87573 }
87574
87575
87576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87577   void * jresult ;
87578   Dali::Toolkit::ProgressBar result;
87579
87580   {
87581     try {
87582       result = Dali::Toolkit::ProgressBar::New();
87583     } catch (std::out_of_range& e) {
87584       {
87585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87586       };
87587     } catch (std::exception& e) {
87588       {
87589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87590       };
87591     } catch (Dali::DaliException e) {
87592       {
87593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87594       };
87595     } catch (...) {
87596       {
87597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87598       };
87599     }
87600   }
87601
87602   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87603   return jresult;
87604 }
87605
87606
87607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87608   void * jresult ;
87609   Dali::Toolkit::ProgressBar *result = 0 ;
87610
87611   {
87612     try {
87613       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87614     } catch (std::out_of_range& e) {
87615       {
87616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87617       };
87618     } catch (std::exception& e) {
87619       {
87620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87621       };
87622     } catch (Dali::DaliException e) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87625       };
87626     } catch (...) {
87627       {
87628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87629       };
87630     }
87631   }
87632
87633   jresult = (void *)result;
87634   return jresult;
87635 }
87636
87637
87638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87639   void * jresult ;
87640   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87641   Dali::Toolkit::ProgressBar *result = 0 ;
87642
87643   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87644   if (!arg1) {
87645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87646     return 0;
87647   }
87648   {
87649     try {
87650       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (Dali::DaliException e) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87662       };
87663     } catch (...) {
87664       {
87665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87666       };
87667     }
87668   }
87669
87670   jresult = (void *)result;
87671   return jresult;
87672 }
87673
87674
87675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87676   void * jresult ;
87677   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87678   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87679   Dali::Toolkit::ProgressBar *result = 0 ;
87680
87681   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87682   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87683   if (!arg2) {
87684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87685     return 0;
87686   }
87687   {
87688     try {
87689       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87690     } catch (std::out_of_range& e) {
87691       {
87692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87693       };
87694     } catch (std::exception& e) {
87695       {
87696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87697       };
87698     } catch (Dali::DaliException e) {
87699       {
87700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87701       };
87702     } catch (...) {
87703       {
87704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87705       };
87706     }
87707   }
87708
87709   jresult = (void *)result;
87710   return jresult;
87711 }
87712
87713
87714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87715   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87716
87717   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87718   {
87719     try {
87720       delete arg1;
87721     } catch (std::out_of_range& e) {
87722       {
87723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87724       };
87725     } catch (std::exception& e) {
87726       {
87727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87728       };
87729     } catch (Dali::DaliException e) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87732       };
87733     } catch (...) {
87734       {
87735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87736       };
87737     }
87738   }
87739
87740 }
87741
87742
87743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87744   void * jresult ;
87745   Dali::BaseHandle arg1 ;
87746   Dali::BaseHandle *argp1 ;
87747   Dali::Toolkit::ProgressBar result;
87748
87749   argp1 = (Dali::BaseHandle *)jarg1;
87750   if (!argp1) {
87751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87752     return 0;
87753   }
87754   arg1 = *argp1;
87755   {
87756     try {
87757       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87758     } catch (std::out_of_range& e) {
87759       {
87760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87761       };
87762     } catch (std::exception& e) {
87763       {
87764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87765       };
87766     } catch (Dali::DaliException e) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87769       };
87770     } catch (...) {
87771       {
87772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87773       };
87774     }
87775   }
87776
87777   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87783   void * jresult ;
87784   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87785   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87786
87787   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87788   {
87789     try {
87790       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87791     } catch (std::out_of_range& e) {
87792       {
87793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87794       };
87795     } catch (std::exception& e) {
87796       {
87797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87798       };
87799     } catch (Dali::DaliException e) {
87800       {
87801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87802       };
87803     } catch (...) {
87804       {
87805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87806       };
87807     }
87808   }
87809
87810   jresult = (void *)result;
87811   return jresult;
87812 }
87813
87814
87815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87816   void * jresult ;
87817   Dali::Toolkit::GaussianBlurView *result = 0 ;
87818
87819   {
87820     try {
87821       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87822     } catch (std::out_of_range& e) {
87823       {
87824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87825       };
87826     } catch (std::exception& e) {
87827       {
87828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87829       };
87830     } catch (Dali::DaliException e) {
87831       {
87832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87833       };
87834     } catch (...) {
87835       {
87836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87837       };
87838     }
87839   }
87840
87841   jresult = (void *)result;
87842   return jresult;
87843 }
87844
87845
87846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87847   void * jresult ;
87848   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
87849   Dali::Toolkit::GaussianBlurView *result = 0 ;
87850
87851   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87852   if (!arg1) {
87853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87854     return 0;
87855   }
87856   {
87857     try {
87858       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
87859     } catch (std::out_of_range& e) {
87860       {
87861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87862       };
87863     } catch (std::exception& e) {
87864       {
87865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (Dali::DaliException e) {
87868       {
87869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87870       };
87871     } catch (...) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87874       };
87875     }
87876   }
87877
87878   jresult = (void *)result;
87879   return jresult;
87880 }
87881
87882
87883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
87884   void * jresult ;
87885   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87886   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
87887   Dali::Toolkit::GaussianBlurView *result = 0 ;
87888
87889   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87890   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
87891   if (!arg2) {
87892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87893     return 0;
87894   }
87895   {
87896     try {
87897       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
87898     } catch (std::out_of_range& e) {
87899       {
87900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87901       };
87902     } catch (std::exception& e) {
87903       {
87904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87905       };
87906     } catch (Dali::DaliException e) {
87907       {
87908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87909       };
87910     } catch (...) {
87911       {
87912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87913       };
87914     }
87915   }
87916
87917   jresult = (void *)result;
87918   return jresult;
87919 }
87920
87921
87922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
87923   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87924
87925   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87926   {
87927     try {
87928       delete arg1;
87929     } catch (std::out_of_range& e) {
87930       {
87931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87932       };
87933     } catch (std::exception& e) {
87934       {
87935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87936       };
87937     } catch (Dali::DaliException e) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87940       };
87941     } catch (...) {
87942       {
87943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87944       };
87945     }
87946   }
87947
87948 }
87949
87950
87951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
87952   void * jresult ;
87953   Dali::BaseHandle arg1 ;
87954   Dali::BaseHandle *argp1 ;
87955   Dali::Toolkit::GaussianBlurView result;
87956
87957   argp1 = (Dali::BaseHandle *)jarg1;
87958   if (!argp1) {
87959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87960     return 0;
87961   }
87962   arg1 = *argp1;
87963   {
87964     try {
87965       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
87966     } catch (std::out_of_range& e) {
87967       {
87968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87969       };
87970     } catch (std::exception& e) {
87971       {
87972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87973       };
87974     } catch (Dali::DaliException e) {
87975       {
87976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87977       };
87978     } catch (...) {
87979       {
87980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87981       };
87982     }
87983   }
87984
87985   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87986   return jresult;
87987 }
87988
87989
87990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
87991   void * jresult ;
87992   Dali::Toolkit::GaussianBlurView result;
87993
87994   {
87995     try {
87996       result = Dali::Toolkit::GaussianBlurView::New();
87997     } catch (std::out_of_range& e) {
87998       {
87999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88000       };
88001     } catch (std::exception& e) {
88002       {
88003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88004       };
88005     } catch (Dali::DaliException e) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88008       };
88009     } catch (...) {
88010       {
88011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88012       };
88013     }
88014   }
88015
88016   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88017   return jresult;
88018 }
88019
88020
88021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88022   void * jresult ;
88023   unsigned int arg1 ;
88024   float arg2 ;
88025   Dali::Pixel::Format arg3 ;
88026   float arg4 ;
88027   float arg5 ;
88028   bool arg6 ;
88029   Dali::Toolkit::GaussianBlurView result;
88030
88031   arg1 = (unsigned int)jarg1;
88032   arg2 = (float)jarg2;
88033   arg3 = (Dali::Pixel::Format)jarg3;
88034   arg4 = (float)jarg4;
88035   arg5 = (float)jarg5;
88036   arg6 = jarg6 ? true : false;
88037   {
88038     try {
88039       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88040     } catch (std::out_of_range& e) {
88041       {
88042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88043       };
88044     } catch (std::exception& e) {
88045       {
88046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88047       };
88048     } catch (Dali::DaliException e) {
88049       {
88050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88051       };
88052     } catch (...) {
88053       {
88054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88055       };
88056     }
88057   }
88058
88059   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88060   return jresult;
88061 }
88062
88063
88064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88065   void * jresult ;
88066   unsigned int arg1 ;
88067   float arg2 ;
88068   Dali::Pixel::Format arg3 ;
88069   float arg4 ;
88070   float arg5 ;
88071   Dali::Toolkit::GaussianBlurView result;
88072
88073   arg1 = (unsigned int)jarg1;
88074   arg2 = (float)jarg2;
88075   arg3 = (Dali::Pixel::Format)jarg3;
88076   arg4 = (float)jarg4;
88077   arg5 = (float)jarg5;
88078   {
88079     try {
88080       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88081     } catch (std::out_of_range& e) {
88082       {
88083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88084       };
88085     } catch (std::exception& e) {
88086       {
88087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88088       };
88089     } catch (Dali::DaliException e) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88092       };
88093     } catch (...) {
88094       {
88095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88096       };
88097     }
88098   }
88099
88100   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88101   return jresult;
88102 }
88103
88104
88105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88106   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88107   Dali::Actor arg2 ;
88108   Dali::Actor *argp2 ;
88109
88110   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88111   argp2 = (Dali::Actor *)jarg2;
88112   if (!argp2) {
88113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88114     return ;
88115   }
88116   arg2 = *argp2;
88117   {
88118     try {
88119       (arg1)->Add(arg2);
88120     } catch (std::out_of_range& e) {
88121       {
88122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88123       };
88124     } catch (std::exception& e) {
88125       {
88126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88127       };
88128     } catch (Dali::DaliException e) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88131       };
88132     } catch (...) {
88133       {
88134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88135       };
88136     }
88137   }
88138
88139 }
88140
88141
88142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88143   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88144   Dali::Actor arg2 ;
88145   Dali::Actor *argp2 ;
88146
88147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88148   argp2 = (Dali::Actor *)jarg2;
88149   if (!argp2) {
88150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88151     return ;
88152   }
88153   arg2 = *argp2;
88154   {
88155     try {
88156       (arg1)->Remove(arg2);
88157     } catch (std::out_of_range& e) {
88158       {
88159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (std::exception& e) {
88162       {
88163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88164       };
88165     } catch (Dali::DaliException e) {
88166       {
88167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88168       };
88169     } catch (...) {
88170       {
88171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88172       };
88173     }
88174   }
88175
88176 }
88177
88178
88179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88180   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88181
88182   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88183   {
88184     try {
88185       (arg1)->Activate();
88186     } catch (std::out_of_range& e) {
88187       {
88188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88189       };
88190     } catch (std::exception& e) {
88191       {
88192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88193       };
88194     } catch (Dali::DaliException e) {
88195       {
88196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88197       };
88198     } catch (...) {
88199       {
88200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88201       };
88202     }
88203   }
88204
88205 }
88206
88207
88208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88209   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88210
88211   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88212   {
88213     try {
88214       (arg1)->ActivateOnce();
88215     } catch (std::out_of_range& e) {
88216       {
88217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88218       };
88219     } catch (std::exception& e) {
88220       {
88221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88222       };
88223     } catch (Dali::DaliException e) {
88224       {
88225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88226       };
88227     } catch (...) {
88228       {
88229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88230       };
88231     }
88232   }
88233
88234 }
88235
88236
88237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88239
88240   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88241   {
88242     try {
88243       (arg1)->Deactivate();
88244     } catch (std::out_of_range& e) {
88245       {
88246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88247       };
88248     } catch (std::exception& e) {
88249       {
88250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88251       };
88252     } catch (Dali::DaliException e) {
88253       {
88254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88255       };
88256     } catch (...) {
88257       {
88258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88259       };
88260     }
88261   }
88262
88263 }
88264
88265
88266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88267   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88268   Dali::Texture arg2 ;
88269   Dali::FrameBuffer arg3 ;
88270   Dali::Texture *argp2 ;
88271   Dali::FrameBuffer *argp3 ;
88272
88273   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88274   argp2 = (Dali::Texture *)jarg2;
88275   if (!argp2) {
88276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88277     return ;
88278   }
88279   arg2 = *argp2;
88280   argp3 = (Dali::FrameBuffer *)jarg3;
88281   if (!argp3) {
88282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88283     return ;
88284   }
88285   arg3 = *argp3;
88286   {
88287     try {
88288       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88289     } catch (std::out_of_range& e) {
88290       {
88291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88292       };
88293     } catch (std::exception& e) {
88294       {
88295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88296       };
88297     } catch (Dali::DaliException e) {
88298       {
88299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88300       };
88301     } catch (...) {
88302       {
88303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88304       };
88305     }
88306   }
88307
88308 }
88309
88310
88311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88312   int jresult ;
88313   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88314   Dali::Property::Index result;
88315
88316   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88317   {
88318     try {
88319       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88320     } catch (std::out_of_range& e) {
88321       {
88322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88323       };
88324     } catch (std::exception& e) {
88325       {
88326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88327       };
88328     } catch (Dali::DaliException e) {
88329       {
88330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88331       };
88332     } catch (...) {
88333       {
88334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88335       };
88336     }
88337   }
88338
88339   jresult = result;
88340   return jresult;
88341 }
88342
88343
88344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88345   void * jresult ;
88346   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88347   Dali::FrameBuffer result;
88348
88349   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88350   {
88351     try {
88352       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88353     } catch (std::out_of_range& e) {
88354       {
88355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88356       };
88357     } catch (std::exception& e) {
88358       {
88359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88360       };
88361     } catch (Dali::DaliException e) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88364       };
88365     } catch (...) {
88366       {
88367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88368       };
88369     }
88370   }
88371
88372   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88373   return jresult;
88374 }
88375
88376
88377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88378   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88379   Dali::Vector4 *arg2 = 0 ;
88380
88381   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88382   arg2 = (Dali::Vector4 *)jarg2;
88383   if (!arg2) {
88384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88385     return ;
88386   }
88387   {
88388     try {
88389       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88390     } catch (std::out_of_range& e) {
88391       {
88392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88393       };
88394     } catch (std::exception& e) {
88395       {
88396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88397       };
88398     } catch (Dali::DaliException e) {
88399       {
88400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88401       };
88402     } catch (...) {
88403       {
88404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88405       };
88406     }
88407   }
88408
88409 }
88410
88411
88412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88413   void * jresult ;
88414   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88415   Dali::Vector4 result;
88416
88417   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88418   {
88419     try {
88420       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88421     } catch (std::out_of_range& e) {
88422       {
88423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88424       };
88425     } catch (std::exception& e) {
88426       {
88427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88428       };
88429     } catch (Dali::DaliException e) {
88430       {
88431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88432       };
88433     } catch (...) {
88434       {
88435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88436       };
88437     }
88438   }
88439
88440   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88441   return jresult;
88442 }
88443
88444
88445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88446   void * jresult ;
88447   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88448   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88449
88450   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88451   {
88452     try {
88453       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88454     } catch (std::out_of_range& e) {
88455       {
88456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (std::exception& e) {
88459       {
88460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88461       };
88462     } catch (Dali::DaliException e) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88469       };
88470     }
88471   }
88472
88473   jresult = (void *)result;
88474   return jresult;
88475 }
88476
88477
88478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88479   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88480
88481   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88482   {
88483     try {
88484       delete arg1;
88485     } catch (std::out_of_range& e) {
88486       {
88487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88488       };
88489     } catch (std::exception& e) {
88490       {
88491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88492       };
88493     } catch (Dali::DaliException e) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88496       };
88497     } catch (...) {
88498       {
88499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88500       };
88501     }
88502   }
88503
88504 }
88505
88506
88507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88508   unsigned int jresult ;
88509   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88510   unsigned int result;
88511
88512   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88513   {
88514     try {
88515       result = (unsigned int)(arg1)->GetNumberOfPages();
88516     } catch (std::out_of_range& e) {
88517       {
88518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (std::exception& e) {
88521       {
88522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88523       };
88524     } catch (Dali::DaliException e) {
88525       {
88526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88527       };
88528     } catch (...) {
88529       {
88530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88531       };
88532     }
88533   }
88534
88535   jresult = result;
88536   return jresult;
88537 }
88538
88539
88540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88541   void * jresult ;
88542   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88543   unsigned int arg2 ;
88544   Dali::Texture result;
88545
88546   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88547   arg2 = (unsigned int)jarg2;
88548   {
88549     try {
88550       result = (arg1)->NewPage(arg2);
88551     } catch (std::out_of_range& e) {
88552       {
88553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88554       };
88555     } catch (std::exception& e) {
88556       {
88557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88558       };
88559     } catch (Dali::DaliException e) {
88560       {
88561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88562       };
88563     } catch (...) {
88564       {
88565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88566       };
88567     }
88568   }
88569
88570   jresult = new Dali::Texture((const Dali::Texture &)result);
88571   return jresult;
88572 }
88573
88574
88575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88576   int jresult ;
88577   int result;
88578
88579   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88580   jresult = (int)result;
88581   return jresult;
88582 }
88583
88584
88585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88586   int jresult ;
88587   int result;
88588
88589   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88590   jresult = (int)result;
88591   return jresult;
88592 }
88593
88594
88595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88596   int jresult ;
88597   int result;
88598
88599   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88600   jresult = (int)result;
88601   return jresult;
88602 }
88603
88604
88605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88606   void * jresult ;
88607   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88608
88609   {
88610     try {
88611       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88612     } catch (std::out_of_range& e) {
88613       {
88614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (std::exception& e) {
88617       {
88618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88619       };
88620     } catch (Dali::DaliException e) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88623       };
88624     } catch (...) {
88625       {
88626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88627       };
88628     }
88629   }
88630
88631   jresult = (void *)result;
88632   return jresult;
88633 }
88634
88635
88636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88637   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88638
88639   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88640   {
88641     try {
88642       delete arg1;
88643     } catch (std::out_of_range& e) {
88644       {
88645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88646       };
88647     } catch (std::exception& e) {
88648       {
88649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88650       };
88651     } catch (Dali::DaliException e) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88654       };
88655     } catch (...) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88658       };
88659     }
88660   }
88661
88662 }
88663
88664
88665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88666   void * jresult ;
88667   Dali::Toolkit::PageTurnView *result = 0 ;
88668
88669   {
88670     try {
88671       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88672     } catch (std::out_of_range& e) {
88673       {
88674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88675       };
88676     } catch (std::exception& e) {
88677       {
88678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88679       };
88680     } catch (Dali::DaliException e) {
88681       {
88682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88683       };
88684     } catch (...) {
88685       {
88686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88687       };
88688     }
88689   }
88690
88691   jresult = (void *)result;
88692   return jresult;
88693 }
88694
88695
88696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88697   void * jresult ;
88698   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88699   Dali::Toolkit::PageTurnView *result = 0 ;
88700
88701   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88702   if (!arg1) {
88703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88704     return 0;
88705   }
88706   {
88707     try {
88708       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88709     } catch (std::out_of_range& e) {
88710       {
88711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88712       };
88713     } catch (std::exception& e) {
88714       {
88715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88716       };
88717     } catch (Dali::DaliException e) {
88718       {
88719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88720       };
88721     } catch (...) {
88722       {
88723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88724       };
88725     }
88726   }
88727
88728   jresult = (void *)result;
88729   return jresult;
88730 }
88731
88732
88733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88734   void * jresult ;
88735   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88736   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88737   Dali::Toolkit::PageTurnView *result = 0 ;
88738
88739   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88740   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88741   if (!arg2) {
88742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88743     return 0;
88744   }
88745   {
88746     try {
88747       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88748     } catch (std::out_of_range& e) {
88749       {
88750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (std::exception& e) {
88753       {
88754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88755       };
88756     } catch (Dali::DaliException e) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88759       };
88760     } catch (...) {
88761       {
88762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88763       };
88764     }
88765   }
88766
88767   jresult = (void *)result;
88768   return jresult;
88769 }
88770
88771
88772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88773   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88774
88775   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88776   {
88777     try {
88778       delete arg1;
88779     } catch (std::out_of_range& e) {
88780       {
88781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88782       };
88783     } catch (std::exception& e) {
88784       {
88785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88786       };
88787     } catch (Dali::DaliException e) {
88788       {
88789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88790       };
88791     } catch (...) {
88792       {
88793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88794       };
88795     }
88796   }
88797
88798 }
88799
88800
88801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88802   void * jresult ;
88803   Dali::BaseHandle arg1 ;
88804   Dali::BaseHandle *argp1 ;
88805   Dali::Toolkit::PageTurnView result;
88806
88807   argp1 = (Dali::BaseHandle *)jarg1;
88808   if (!argp1) {
88809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88810     return 0;
88811   }
88812   arg1 = *argp1;
88813   {
88814     try {
88815       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88816     } catch (std::out_of_range& e) {
88817       {
88818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88819       };
88820     } catch (std::exception& e) {
88821       {
88822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88823       };
88824     } catch (Dali::DaliException e) {
88825       {
88826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88827       };
88828     } catch (...) {
88829       {
88830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88831       };
88832     }
88833   }
88834
88835   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88836   return jresult;
88837 }
88838
88839
88840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88841   void * jresult ;
88842   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88843   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88844
88845   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88846   {
88847     try {
88848       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
88849     } catch (std::out_of_range& e) {
88850       {
88851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88852       };
88853     } catch (std::exception& e) {
88854       {
88855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88856       };
88857     } catch (Dali::DaliException e) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88860       };
88861     } catch (...) {
88862       {
88863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88864       };
88865     }
88866   }
88867
88868   jresult = (void *)result;
88869   return jresult;
88870 }
88871
88872
88873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
88874   void * jresult ;
88875   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88876   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88877
88878   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88879   {
88880     try {
88881       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
88882     } catch (std::out_of_range& e) {
88883       {
88884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88885       };
88886     } catch (std::exception& e) {
88887       {
88888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88889       };
88890     } catch (Dali::DaliException e) {
88891       {
88892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88893       };
88894     } catch (...) {
88895       {
88896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88897       };
88898     }
88899   }
88900
88901   jresult = (void *)result;
88902   return jresult;
88903 }
88904
88905
88906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
88907   void * jresult ;
88908   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88909   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88910
88911   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88912   {
88913     try {
88914       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
88915     } catch (std::out_of_range& e) {
88916       {
88917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88918       };
88919     } catch (std::exception& e) {
88920       {
88921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88922       };
88923     } catch (Dali::DaliException e) {
88924       {
88925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88926       };
88927     } catch (...) {
88928       {
88929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88930       };
88931     }
88932   }
88933
88934   jresult = (void *)result;
88935   return jresult;
88936 }
88937
88938
88939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
88940   void * jresult ;
88941   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88942   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88943
88944   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88945   {
88946     try {
88947       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
88948     } catch (std::out_of_range& e) {
88949       {
88950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88951       };
88952     } catch (std::exception& e) {
88953       {
88954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88955       };
88956     } catch (Dali::DaliException e) {
88957       {
88958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88959       };
88960     } catch (...) {
88961       {
88962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88963       };
88964     }
88965   }
88966
88967   jresult = (void *)result;
88968   return jresult;
88969 }
88970
88971
88972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
88973   void * jresult ;
88974   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88975
88976   {
88977     try {
88978       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
88979     } catch (std::out_of_range& e) {
88980       {
88981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88982       };
88983     } catch (std::exception& e) {
88984       {
88985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88986       };
88987     } catch (Dali::DaliException e) {
88988       {
88989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88990       };
88991     } catch (...) {
88992       {
88993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88994       };
88995     }
88996   }
88997
88998   jresult = (void *)result;
88999   return jresult;
89000 }
89001
89002
89003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89004   void * jresult ;
89005   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89006   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89007
89008   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89009   if (!arg1) {
89010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89011     return 0;
89012   }
89013   {
89014     try {
89015       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89016     } catch (std::out_of_range& e) {
89017       {
89018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (std::exception& e) {
89021       {
89022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89023       };
89024     } catch (Dali::DaliException e) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89027       };
89028     } catch (...) {
89029       {
89030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89031       };
89032     }
89033   }
89034
89035   jresult = (void *)result;
89036   return jresult;
89037 }
89038
89039
89040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89041   void * jresult ;
89042   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89043   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89044   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89045
89046   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89047   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89048   if (!arg2) {
89049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89050     return 0;
89051   }
89052   {
89053     try {
89054       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89055     } catch (std::out_of_range& e) {
89056       {
89057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89058       };
89059     } catch (std::exception& e) {
89060       {
89061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89062       };
89063     } catch (Dali::DaliException e) {
89064       {
89065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89066       };
89067     } catch (...) {
89068       {
89069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89070       };
89071     }
89072   }
89073
89074   jresult = (void *)result;
89075   return jresult;
89076 }
89077
89078
89079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89080   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89081
89082   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89083   {
89084     try {
89085       delete arg1;
89086     } catch (std::out_of_range& e) {
89087       {
89088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89089       };
89090     } catch (std::exception& e) {
89091       {
89092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89093       };
89094     } catch (Dali::DaliException e) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89097       };
89098     } catch (...) {
89099       {
89100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89101       };
89102     }
89103   }
89104
89105 }
89106
89107
89108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89109   void * jresult ;
89110   Dali::Toolkit::PageFactory *arg1 = 0 ;
89111   Dali::Vector2 *arg2 = 0 ;
89112   Dali::Toolkit::PageTurnLandscapeView result;
89113
89114   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89115   if (!arg1) {
89116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89117     return 0;
89118   }
89119   arg2 = (Dali::Vector2 *)jarg2;
89120   if (!arg2) {
89121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89122     return 0;
89123   }
89124   {
89125     try {
89126       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89127     } catch (std::out_of_range& e) {
89128       {
89129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89130       };
89131     } catch (std::exception& e) {
89132       {
89133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89134       };
89135     } catch (Dali::DaliException e) {
89136       {
89137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89138       };
89139     } catch (...) {
89140       {
89141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89142       };
89143     }
89144   }
89145
89146   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89147   return jresult;
89148 }
89149
89150
89151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89152   void * jresult ;
89153   Dali::BaseHandle arg1 ;
89154   Dali::BaseHandle *argp1 ;
89155   Dali::Toolkit::PageTurnLandscapeView result;
89156
89157   argp1 = (Dali::BaseHandle *)jarg1;
89158   if (!argp1) {
89159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89160     return 0;
89161   }
89162   arg1 = *argp1;
89163   {
89164     try {
89165       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89166     } catch (std::out_of_range& e) {
89167       {
89168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89169       };
89170     } catch (std::exception& e) {
89171       {
89172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89173       };
89174     } catch (Dali::DaliException e) {
89175       {
89176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89177       };
89178     } catch (...) {
89179       {
89180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89181       };
89182     }
89183   }
89184
89185   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89186   return jresult;
89187 }
89188
89189
89190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89191   void * jresult ;
89192   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89193
89194   {
89195     try {
89196       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89197     } catch (std::out_of_range& e) {
89198       {
89199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89200       };
89201     } catch (std::exception& e) {
89202       {
89203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89204       };
89205     } catch (Dali::DaliException e) {
89206       {
89207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89208       };
89209     } catch (...) {
89210       {
89211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89212       };
89213     }
89214   }
89215
89216   jresult = (void *)result;
89217   return jresult;
89218 }
89219
89220
89221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89222   void * jresult ;
89223   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89224   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89225
89226   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89227   if (!arg1) {
89228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89229     return 0;
89230   }
89231   {
89232     try {
89233       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89234     } catch (std::out_of_range& e) {
89235       {
89236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89237       };
89238     } catch (std::exception& e) {
89239       {
89240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89241       };
89242     } catch (Dali::DaliException e) {
89243       {
89244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89245       };
89246     } catch (...) {
89247       {
89248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89249       };
89250     }
89251   }
89252
89253   jresult = (void *)result;
89254   return jresult;
89255 }
89256
89257
89258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89259   void * jresult ;
89260   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89261   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89262   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89263
89264   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89265   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89266   if (!arg2) {
89267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89268     return 0;
89269   }
89270   {
89271     try {
89272       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89273     } catch (std::out_of_range& e) {
89274       {
89275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89276       };
89277     } catch (std::exception& e) {
89278       {
89279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89280       };
89281     } catch (Dali::DaliException e) {
89282       {
89283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89284       };
89285     } catch (...) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89288       };
89289     }
89290   }
89291
89292   jresult = (void *)result;
89293   return jresult;
89294 }
89295
89296
89297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89298   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89299
89300   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89301   {
89302     try {
89303       delete arg1;
89304     } catch (std::out_of_range& e) {
89305       {
89306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89307       };
89308     } catch (std::exception& e) {
89309       {
89310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89311       };
89312     } catch (Dali::DaliException e) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89315       };
89316     } catch (...) {
89317       {
89318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89319       };
89320     }
89321   }
89322
89323 }
89324
89325
89326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89327   void * jresult ;
89328   Dali::Toolkit::PageFactory *arg1 = 0 ;
89329   Dali::Vector2 *arg2 = 0 ;
89330   Dali::Toolkit::PageTurnPortraitView result;
89331
89332   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89333   if (!arg1) {
89334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89335     return 0;
89336   }
89337   arg2 = (Dali::Vector2 *)jarg2;
89338   if (!arg2) {
89339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89340     return 0;
89341   }
89342   {
89343     try {
89344       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89345     } catch (std::out_of_range& e) {
89346       {
89347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89348       };
89349     } catch (std::exception& e) {
89350       {
89351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89352       };
89353     } catch (Dali::DaliException e) {
89354       {
89355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89356       };
89357     } catch (...) {
89358       {
89359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89360       };
89361     }
89362   }
89363
89364   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89365   return jresult;
89366 }
89367
89368
89369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89370   void * jresult ;
89371   Dali::BaseHandle arg1 ;
89372   Dali::BaseHandle *argp1 ;
89373   Dali::Toolkit::PageTurnPortraitView result;
89374
89375   argp1 = (Dali::BaseHandle *)jarg1;
89376   if (!argp1) {
89377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89378     return 0;
89379   }
89380   arg1 = *argp1;
89381   {
89382     try {
89383       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89384     } catch (std::out_of_range& e) {
89385       {
89386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (std::exception& e) {
89389       {
89390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89391       };
89392     } catch (Dali::DaliException e) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89395       };
89396     } catch (...) {
89397       {
89398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89399       };
89400     }
89401   }
89402
89403   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89404   return jresult;
89405 }
89406
89407
89408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89409   int jresult ;
89410   int result;
89411
89412   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89413   jresult = (int)result;
89414   return jresult;
89415 }
89416
89417
89418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89419   int jresult ;
89420   int result;
89421
89422   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89423   jresult = (int)result;
89424   return jresult;
89425 }
89426
89427
89428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89429   int jresult ;
89430   int result;
89431
89432   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89433   jresult = (int)result;
89434   return jresult;
89435 }
89436
89437
89438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89439   void * jresult ;
89440   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89441
89442   {
89443     try {
89444       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89445     } catch (std::out_of_range& e) {
89446       {
89447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89448       };
89449     } catch (std::exception& e) {
89450       {
89451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89452       };
89453     } catch (Dali::DaliException e) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89456       };
89457     } catch (...) {
89458       {
89459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89460       };
89461     }
89462   }
89463
89464   jresult = (void *)result;
89465   return jresult;
89466 }
89467
89468
89469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89470   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89471
89472   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89473   {
89474     try {
89475       delete arg1;
89476     } catch (std::out_of_range& e) {
89477       {
89478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89479       };
89480     } catch (std::exception& e) {
89481       {
89482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89483       };
89484     } catch (Dali::DaliException e) {
89485       {
89486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89487       };
89488     } catch (...) {
89489       {
89490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89491       };
89492     }
89493   }
89494
89495 }
89496
89497
89498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89499   void * jresult ;
89500   Dali::Toolkit::ToggleButton *result = 0 ;
89501
89502   {
89503     try {
89504       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89505     } catch (std::out_of_range& e) {
89506       {
89507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89508       };
89509     } catch (std::exception& e) {
89510       {
89511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89512       };
89513     } catch (Dali::DaliException e) {
89514       {
89515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89516       };
89517     } catch (...) {
89518       {
89519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89520       };
89521     }
89522   }
89523
89524   jresult = (void *)result;
89525   return jresult;
89526 }
89527
89528
89529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89530   void * jresult ;
89531   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89532   Dali::Toolkit::ToggleButton *result = 0 ;
89533
89534   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89535   if (!arg1) {
89536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89537     return 0;
89538   }
89539   {
89540     try {
89541       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89542     } catch (std::out_of_range& e) {
89543       {
89544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89545       };
89546     } catch (std::exception& e) {
89547       {
89548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89549       };
89550     } catch (Dali::DaliException e) {
89551       {
89552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89553       };
89554     } catch (...) {
89555       {
89556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89557       };
89558     }
89559   }
89560
89561   jresult = (void *)result;
89562   return jresult;
89563 }
89564
89565
89566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89567   void * jresult ;
89568   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89569   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89570   Dali::Toolkit::ToggleButton *result = 0 ;
89571
89572   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89573   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89574   if (!arg2) {
89575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89576     return 0;
89577   }
89578   {
89579     try {
89580       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89581     } catch (std::out_of_range& e) {
89582       {
89583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (std::exception& e) {
89586       {
89587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (Dali::DaliException e) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89592       };
89593     } catch (...) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89596       };
89597     }
89598   }
89599
89600   jresult = (void *)result;
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89606   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89607
89608   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89609   {
89610     try {
89611       delete arg1;
89612     } catch (std::out_of_range& e) {
89613       {
89614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89615       };
89616     } catch (std::exception& e) {
89617       {
89618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89619       };
89620     } catch (Dali::DaliException e) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89623       };
89624     } catch (...) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89627       };
89628     }
89629   }
89630
89631 }
89632
89633
89634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89635   void * jresult ;
89636   Dali::Toolkit::ToggleButton result;
89637
89638   {
89639     try {
89640       result = Dali::Toolkit::ToggleButton::New();
89641     } catch (std::out_of_range& e) {
89642       {
89643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (std::exception& e) {
89646       {
89647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89648       };
89649     } catch (Dali::DaliException e) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89652       };
89653     } catch (...) {
89654       {
89655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89656       };
89657     }
89658   }
89659
89660   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89661   return jresult;
89662 }
89663
89664
89665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89666   void * jresult ;
89667   Dali::BaseHandle arg1 ;
89668   Dali::BaseHandle *argp1 ;
89669   Dali::Toolkit::ToggleButton result;
89670
89671   argp1 = (Dali::BaseHandle *)jarg1;
89672   if (!argp1) {
89673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89674     return 0;
89675   }
89676   arg1 = *argp1;
89677   {
89678     try {
89679       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89680     } catch (std::out_of_range& e) {
89681       {
89682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89683       };
89684     } catch (std::exception& e) {
89685       {
89686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89687       };
89688     } catch (Dali::DaliException e) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89691       };
89692     } catch (...) {
89693       {
89694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89695       };
89696     }
89697   }
89698
89699   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89700   return jresult;
89701 }
89702
89703
89704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89705   void * jresult ;
89706   Dali::Toolkit::Visual::Base *result = 0 ;
89707
89708   {
89709     try {
89710       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89711     } catch (std::out_of_range& e) {
89712       {
89713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89714       };
89715     } catch (std::exception& e) {
89716       {
89717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89718       };
89719     } catch (Dali::DaliException e) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89722       };
89723     } catch (...) {
89724       {
89725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89726       };
89727     }
89728   }
89729
89730   jresult = (void *)result;
89731   return jresult;
89732 }
89733
89734
89735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89736   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89737
89738   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89739   {
89740     try {
89741       delete arg1;
89742     } catch (std::out_of_range& e) {
89743       {
89744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89745       };
89746     } catch (std::exception& e) {
89747       {
89748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89749       };
89750     } catch (Dali::DaliException e) {
89751       {
89752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89753       };
89754     } catch (...) {
89755       {
89756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89757       };
89758     }
89759   }
89760
89761 }
89762
89763
89764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89765   void * jresult ;
89766   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89767   Dali::Toolkit::Visual::Base *result = 0 ;
89768
89769   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89770   if (!arg1) {
89771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89772     return 0;
89773   }
89774   {
89775     try {
89776       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89777     } catch (std::out_of_range& e) {
89778       {
89779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89780       };
89781     } catch (std::exception& e) {
89782       {
89783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89784       };
89785     } catch (Dali::DaliException e) {
89786       {
89787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89788       };
89789     } catch (...) {
89790       {
89791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89792       };
89793     }
89794   }
89795
89796   jresult = (void *)result;
89797   return jresult;
89798 }
89799
89800
89801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89802   void * jresult ;
89803   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89804   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89805   Dali::Toolkit::Visual::Base *result = 0 ;
89806
89807   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89808   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89809   if (!arg2) {
89810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89811     return 0;
89812   }
89813   {
89814     try {
89815       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89816     } catch (std::out_of_range& e) {
89817       {
89818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89819       };
89820     } catch (std::exception& e) {
89821       {
89822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89823       };
89824     } catch (Dali::DaliException e) {
89825       {
89826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89827       };
89828     } catch (...) {
89829       {
89830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89831       };
89832     }
89833   }
89834
89835   jresult = (void *)result;
89836   return jresult;
89837 }
89838
89839
89840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89841   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89842   std::string *arg2 = 0 ;
89843
89844   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89845   if (!jarg2) {
89846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89847     return ;
89848   }
89849   std::string arg2_str(jarg2);
89850   arg2 = &arg2_str;
89851   {
89852     try {
89853       (arg1)->SetName((std::string const &)*arg2);
89854     } catch (std::out_of_range& e) {
89855       {
89856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89857       };
89858     } catch (std::exception& e) {
89859       {
89860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (Dali::DaliException e) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89865       };
89866     } catch (...) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89869       };
89870     }
89871   }
89872
89873
89874   //argout typemap for const std::string&
89875
89876 }
89877
89878
89879 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
89880   char * jresult ;
89881   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89882   std::string *result = 0 ;
89883
89884   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89885   {
89886     try {
89887       result = (std::string *) &(arg1)->GetName();
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89895       };
89896     } catch (Dali::DaliException e) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89903       };
89904     }
89905   }
89906
89907   jresult = SWIG_csharp_string_callback(result->c_str());
89908   return jresult;
89909 }
89910
89911
89912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
89913   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89914   Dali::Property::Map *arg2 = 0 ;
89915   Dali::Size arg3 ;
89916   Dali::Size *argp3 ;
89917
89918   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89919   arg2 = (Dali::Property::Map *)jarg2;
89920   if (!arg2) {
89921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89922     return ;
89923   }
89924   argp3 = (Dali::Size *)jarg3;
89925   if (!argp3) {
89926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
89927     return ;
89928   }
89929   arg3 = *argp3;
89930   {
89931     try {
89932       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
89933     } catch (std::out_of_range& e) {
89934       {
89935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89936       };
89937     } catch (std::exception& e) {
89938       {
89939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89940       };
89941     } catch (Dali::DaliException e) {
89942       {
89943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89944       };
89945     } catch (...) {
89946       {
89947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89948       };
89949     }
89950   }
89951
89952 }
89953
89954
89955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
89956   float jresult ;
89957   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89958   float arg2 ;
89959   float result;
89960
89961   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89962   arg2 = (float)jarg2;
89963   {
89964     try {
89965       result = (float)(arg1)->GetHeightForWidth(arg2);
89966     } catch (std::out_of_range& e) {
89967       {
89968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89969       };
89970     } catch (std::exception& e) {
89971       {
89972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89973       };
89974     } catch (Dali::DaliException e) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89977       };
89978     } catch (...) {
89979       {
89980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89981       };
89982     }
89983   }
89984
89985   jresult = result;
89986   return jresult;
89987 }
89988
89989
89990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
89991   float jresult ;
89992   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89993   float arg2 ;
89994   float result;
89995
89996   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89997   arg2 = (float)jarg2;
89998   {
89999     try {
90000       result = (float)(arg1)->GetWidthForHeight(arg2);
90001     } catch (std::out_of_range& e) {
90002       {
90003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90004       };
90005     } catch (std::exception& e) {
90006       {
90007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90008       };
90009     } catch (Dali::DaliException e) {
90010       {
90011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90012       };
90013     } catch (...) {
90014       {
90015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90016       };
90017     }
90018   }
90019
90020   jresult = result;
90021   return jresult;
90022 }
90023
90024
90025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90026   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90027   Dali::Vector2 *arg2 = 0 ;
90028
90029   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90030   arg2 = (Dali::Vector2 *)jarg2;
90031   if (!arg2) {
90032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90033     return ;
90034   }
90035   {
90036     try {
90037       (arg1)->GetNaturalSize(*arg2);
90038     } catch (std::out_of_range& e) {
90039       {
90040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90041       };
90042     } catch (std::exception& e) {
90043       {
90044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90045       };
90046     } catch (Dali::DaliException e) {
90047       {
90048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90049       };
90050     } catch (...) {
90051       {
90052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90053       };
90054     }
90055   }
90056
90057 }
90058
90059
90060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90061   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90062   float arg2 ;
90063
90064   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90065   arg2 = (int)jarg2;
90066   {
90067     try {
90068       (arg1)->SetDepthIndex(arg2);
90069     } catch (std::out_of_range& e) {
90070       {
90071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90072       };
90073     } catch (std::exception& e) {
90074       {
90075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90076       };
90077     } catch (Dali::DaliException e) {
90078       {
90079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90080       };
90081     } catch (...) {
90082       {
90083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90084       };
90085     }
90086   }
90087
90088 }
90089
90090
90091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90092   int jresult ;
90093   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90094   int result;
90095
90096   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90097   {
90098     try {
90099       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90100     } catch (std::out_of_range& e) {
90101       {
90102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90103       };
90104     } catch (std::exception& e) {
90105       {
90106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90107       };
90108     } catch (Dali::DaliException e) {
90109       {
90110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90111       };
90112     } catch (...) {
90113       {
90114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90115       };
90116     }
90117   }
90118
90119   jresult = result;
90120   return jresult;
90121 }
90122
90123
90124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90125   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90126   Dali::Property::Map *arg2 = 0 ;
90127
90128   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90129   arg2 = (Dali::Property::Map *)jarg2;
90130   if (!arg2) {
90131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90132     return ;
90133   }
90134   {
90135     try {
90136       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90137     } catch (std::out_of_range& e) {
90138       {
90139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90140       };
90141     } catch (std::exception& e) {
90142       {
90143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90144       };
90145     } catch (Dali::DaliException e) {
90146       {
90147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90148       };
90149     } catch (...) {
90150       {
90151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90152       };
90153     }
90154   }
90155
90156 }
90157
90158
90159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90160   void * jresult ;
90161   Dali::Toolkit::VisualFactory result;
90162
90163   {
90164     try {
90165       result = Dali::Toolkit::VisualFactory::Get();
90166     } catch (std::out_of_range& e) {
90167       {
90168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90169       };
90170     } catch (std::exception& e) {
90171       {
90172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90173       };
90174     } catch (Dali::DaliException e) {
90175       {
90176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90177       };
90178     } catch (...) {
90179       {
90180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90181       };
90182     }
90183   }
90184
90185   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90186   return jresult;
90187 }
90188
90189
90190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90191   void * jresult ;
90192   Dali::Toolkit::VisualFactory *result = 0 ;
90193
90194   {
90195     try {
90196       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90197     } catch (std::out_of_range& e) {
90198       {
90199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90200       };
90201     } catch (std::exception& e) {
90202       {
90203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90204       };
90205     } catch (Dali::DaliException e) {
90206       {
90207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90208       };
90209     } catch (...) {
90210       {
90211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90212       };
90213     }
90214   }
90215
90216   jresult = (void *)result;
90217   return jresult;
90218 }
90219
90220
90221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90222   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90223
90224   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90225   {
90226     try {
90227       delete arg1;
90228     } catch (std::out_of_range& e) {
90229       {
90230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90231       };
90232     } catch (std::exception& e) {
90233       {
90234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90235       };
90236     } catch (Dali::DaliException e) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90239       };
90240     } catch (...) {
90241       {
90242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90243       };
90244     }
90245   }
90246
90247 }
90248
90249
90250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90251   void * jresult ;
90252   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90253   Dali::Toolkit::VisualFactory *result = 0 ;
90254
90255   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90256   if (!arg1) {
90257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90258     return 0;
90259   }
90260   {
90261     try {
90262       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90263     } catch (std::out_of_range& e) {
90264       {
90265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90266       };
90267     } catch (std::exception& e) {
90268       {
90269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90270       };
90271     } catch (Dali::DaliException e) {
90272       {
90273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90274       };
90275     } catch (...) {
90276       {
90277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90278       };
90279     }
90280   }
90281
90282   jresult = (void *)result;
90283   return jresult;
90284 }
90285
90286
90287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90288   void * jresult ;
90289   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90290   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90291   Dali::Toolkit::VisualFactory *result = 0 ;
90292
90293   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90294   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90295   if (!arg2) {
90296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90297     return 0;
90298   }
90299   {
90300     try {
90301       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90302     } catch (std::out_of_range& e) {
90303       {
90304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90305       };
90306     } catch (std::exception& e) {
90307       {
90308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90309       };
90310     } catch (Dali::DaliException e) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90313       };
90314     } catch (...) {
90315       {
90316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90317       };
90318     }
90319   }
90320
90321   jresult = (void *)result;
90322   return jresult;
90323 }
90324
90325
90326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90327   void * jresult ;
90328   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90329   Dali::Property::Map *arg2 = 0 ;
90330   Dali::Toolkit::Visual::Base result;
90331
90332   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90333   arg2 = (Dali::Property::Map *)jarg2;
90334   if (!arg2) {
90335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90336     return 0;
90337   }
90338   {
90339     try {
90340       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90341     } catch (std::out_of_range& e) {
90342       {
90343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90344       };
90345     } catch (std::exception& e) {
90346       {
90347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90348       };
90349     } catch (Dali::DaliException e) {
90350       {
90351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90352       };
90353     } catch (...) {
90354       {
90355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90356       };
90357     }
90358   }
90359
90360   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90361   return jresult;
90362 }
90363
90364
90365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90366   void * jresult ;
90367   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90368   Dali::Image *arg2 = 0 ;
90369   Dali::Toolkit::Visual::Base result;
90370
90371   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90372   arg2 = (Dali::Image *)jarg2;
90373   if (!arg2) {
90374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90375     return 0;
90376   }
90377   {
90378     try {
90379       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90380     } catch (std::out_of_range& e) {
90381       {
90382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90383       };
90384     } catch (std::exception& e) {
90385       {
90386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90387       };
90388     } catch (Dali::DaliException e) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90391       };
90392     } catch (...) {
90393       {
90394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90395       };
90396     }
90397   }
90398
90399   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90400   return jresult;
90401 }
90402
90403
90404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90405   void * jresult ;
90406   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90407   std::string *arg2 = 0 ;
90408   Dali::ImageDimensions arg3 ;
90409   Dali::ImageDimensions *argp3 ;
90410   Dali::Toolkit::Visual::Base result;
90411
90412   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90413   if (!jarg2) {
90414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90415     return 0;
90416   }
90417   std::string arg2_str(jarg2);
90418   arg2 = &arg2_str;
90419   argp3 = (Dali::ImageDimensions *)jarg3;
90420   if (!argp3) {
90421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90422     return 0;
90423   }
90424   arg3 = *argp3;
90425   {
90426     try {
90427       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90428     } catch (std::out_of_range& e) {
90429       {
90430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (std::exception& e) {
90433       {
90434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (Dali::DaliException e) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90439       };
90440     } catch (...) {
90441       {
90442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90443       };
90444     }
90445   }
90446
90447   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90448
90449   //argout typemap for const std::string&
90450
90451   return jresult;
90452 }
90453
90454
90455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90456   void * jresult ;
90457   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90458
90459   {
90460     try {
90461       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90462     } catch (std::out_of_range& e) {
90463       {
90464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90465       };
90466     } catch (std::exception& e) {
90467       {
90468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (Dali::DaliException e) {
90471       {
90472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90473       };
90474     } catch (...) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90477       };
90478     }
90479   }
90480
90481   jresult = (void *)result;
90482   return jresult;
90483 }
90484
90485
90486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90487   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90488
90489   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90490   {
90491     try {
90492       delete arg1;
90493     } catch (std::out_of_range& e) {
90494       {
90495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90496       };
90497     } catch (std::exception& e) {
90498       {
90499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90500       };
90501     } catch (Dali::DaliException e) {
90502       {
90503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90504       };
90505     } catch (...) {
90506       {
90507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90508       };
90509     }
90510   }
90511
90512 }
90513
90514
90515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90516   void * jresult ;
90517   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90518   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90519
90520   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90521   if (!arg1) {
90522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90523     return 0;
90524   }
90525   {
90526     try {
90527       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90528     } catch (std::out_of_range& e) {
90529       {
90530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90531       };
90532     } catch (std::exception& e) {
90533       {
90534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90535       };
90536     } catch (Dali::DaliException e) {
90537       {
90538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90539       };
90540     } catch (...) {
90541       {
90542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90543       };
90544     }
90545   }
90546
90547   jresult = (void *)result;
90548   return jresult;
90549 }
90550
90551
90552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90553   void * jresult ;
90554   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90555   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90556   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90557
90558   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90559   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90560   if (!arg2) {
90561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90562     return 0;
90563   }
90564   {
90565     try {
90566       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90567     } catch (std::out_of_range& e) {
90568       {
90569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90570       };
90571     } catch (std::exception& e) {
90572       {
90573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90574       };
90575     } catch (Dali::DaliException e) {
90576       {
90577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90578       };
90579     } catch (...) {
90580       {
90581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90582       };
90583     }
90584   }
90585
90586   jresult = (void *)result;
90587   return jresult;
90588 }
90589
90590
90591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90592   void * jresult ;
90593   Dali::Toolkit::AsyncImageLoader result;
90594
90595   {
90596     try {
90597       result = Dali::Toolkit::AsyncImageLoader::New();
90598     } catch (std::out_of_range& e) {
90599       {
90600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90601       };
90602     } catch (std::exception& e) {
90603       {
90604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90605       };
90606     } catch (Dali::DaliException e) {
90607       {
90608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90609       };
90610     } catch (...) {
90611       {
90612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90613       };
90614     }
90615   }
90616
90617   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90618   return jresult;
90619 }
90620
90621
90622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90623   void * jresult ;
90624   Dali::BaseHandle arg1 ;
90625   Dali::BaseHandle *argp1 ;
90626   Dali::Toolkit::AsyncImageLoader result;
90627
90628   argp1 = (Dali::BaseHandle *)jarg1;
90629   if (!argp1) {
90630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90631     return 0;
90632   }
90633   arg1 = *argp1;
90634   {
90635     try {
90636       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90637     } catch (std::out_of_range& e) {
90638       {
90639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90640       };
90641     } catch (std::exception& e) {
90642       {
90643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90644       };
90645     } catch (Dali::DaliException e) {
90646       {
90647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90648       };
90649     } catch (...) {
90650       {
90651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90652       };
90653     }
90654   }
90655
90656   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90657   return jresult;
90658 }
90659
90660
90661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90662   unsigned int jresult ;
90663   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90664   std::string *arg2 = 0 ;
90665   uint32_t result;
90666
90667   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90668   if (!jarg2) {
90669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90670     return 0;
90671   }
90672   std::string arg2_str(jarg2);
90673   arg2 = &arg2_str;
90674   {
90675     try {
90676       result = (arg1)->Load((std::string const &)*arg2);
90677     } catch (std::out_of_range& e) {
90678       {
90679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90680       };
90681     } catch (std::exception& e) {
90682       {
90683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (Dali::DaliException e) {
90686       {
90687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90688       };
90689     } catch (...) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90692       };
90693     }
90694   }
90695
90696   jresult = result;
90697
90698   //argout typemap for const std::string&
90699
90700   return jresult;
90701 }
90702
90703
90704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90705   unsigned int jresult ;
90706   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90707   std::string *arg2 = 0 ;
90708   Dali::ImageDimensions arg3 ;
90709   Dali::ImageDimensions *argp3 ;
90710   uint32_t result;
90711
90712   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90713   if (!jarg2) {
90714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90715     return 0;
90716   }
90717   std::string arg2_str(jarg2);
90718   arg2 = &arg2_str;
90719   argp3 = (Dali::ImageDimensions *)jarg3;
90720   if (!argp3) {
90721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90722     return 0;
90723   }
90724   arg3 = *argp3;
90725   {
90726     try {
90727       result = (arg1)->Load((std::string const &)*arg2,arg3);
90728     } catch (std::out_of_range& e) {
90729       {
90730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90731       };
90732     } catch (std::exception& e) {
90733       {
90734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90735       };
90736     } catch (Dali::DaliException e) {
90737       {
90738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90739       };
90740     } catch (...) {
90741       {
90742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90743       };
90744     }
90745   }
90746
90747   jresult = result;
90748
90749   //argout typemap for const std::string&
90750
90751   return jresult;
90752 }
90753
90754
90755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90756   unsigned int jresult ;
90757   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90758   std::string *arg2 = 0 ;
90759   Dali::ImageDimensions arg3 ;
90760   Dali::FittingMode::Type arg4 ;
90761   Dali::SamplingMode::Type arg5 ;
90762   bool arg6 ;
90763   Dali::ImageDimensions *argp3 ;
90764   uint32_t result;
90765
90766   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90767   if (!jarg2) {
90768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90769     return 0;
90770   }
90771   std::string arg2_str(jarg2);
90772   arg2 = &arg2_str;
90773   argp3 = (Dali::ImageDimensions *)jarg3;
90774   if (!argp3) {
90775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90776     return 0;
90777   }
90778   arg3 = *argp3;
90779   arg4 = (Dali::FittingMode::Type)jarg4;
90780   arg5 = (Dali::SamplingMode::Type)jarg5;
90781   arg6 = jarg6 ? true : false;
90782   {
90783     try {
90784       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90785     } catch (std::out_of_range& e) {
90786       {
90787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90788       };
90789     } catch (std::exception& e) {
90790       {
90791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90792       };
90793     } catch (Dali::DaliException e) {
90794       {
90795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90796       };
90797     } catch (...) {
90798       {
90799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90800       };
90801     }
90802   }
90803
90804   jresult = result;
90805
90806   //argout typemap for const std::string&
90807
90808   return jresult;
90809 }
90810
90811
90812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90813   unsigned int jresult ;
90814   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90815   uint32_t arg2 ;
90816   bool result;
90817
90818   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90819   arg2 = (uint32_t)jarg2;
90820   {
90821     try {
90822       result = (bool)(arg1)->Cancel(arg2);
90823     } catch (std::out_of_range& e) {
90824       {
90825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90826       };
90827     } catch (std::exception& e) {
90828       {
90829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90830       };
90831     } catch (Dali::DaliException e) {
90832       {
90833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90834       };
90835     } catch (...) {
90836       {
90837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90838       };
90839     }
90840   }
90841
90842   jresult = result;
90843   return jresult;
90844 }
90845
90846
90847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90848   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90849
90850   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90851   {
90852     try {
90853       (arg1)->CancelAll();
90854     } catch (std::out_of_range& e) {
90855       {
90856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90857       };
90858     } catch (std::exception& e) {
90859       {
90860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90861       };
90862     } catch (Dali::DaliException e) {
90863       {
90864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90865       };
90866     } catch (...) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90869       };
90870     }
90871   }
90872
90873 }
90874
90875
90876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
90877   void * jresult ;
90878   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90879   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
90880
90881   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90882   {
90883     try {
90884       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
90885     } catch (std::out_of_range& e) {
90886       {
90887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90888       };
90889     } catch (std::exception& e) {
90890       {
90891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90892       };
90893     } catch (Dali::DaliException e) {
90894       {
90895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90896       };
90897     } catch (...) {
90898       {
90899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90900       };
90901     }
90902   }
90903
90904   jresult = (void *)result;
90905   return jresult;
90906 }
90907
90908
90909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
90910   void * jresult ;
90911   std::string *arg1 = 0 ;
90912   Dali::PixelData result;
90913
90914   if (!jarg1) {
90915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90916     return 0;
90917   }
90918   std::string arg1_str(jarg1);
90919   arg1 = &arg1_str;
90920   {
90921     try {
90922       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
90923     } catch (std::out_of_range& e) {
90924       {
90925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90926       };
90927     } catch (std::exception& e) {
90928       {
90929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90930       };
90931     } catch (Dali::DaliException e) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90934       };
90935     } catch (...) {
90936       {
90937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90938       };
90939     }
90940   }
90941
90942   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90943
90944   //argout typemap for const std::string&
90945
90946   return jresult;
90947 }
90948
90949
90950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
90951   void * jresult ;
90952   std::string *arg1 = 0 ;
90953   Dali::ImageDimensions arg2 ;
90954   Dali::ImageDimensions *argp2 ;
90955   Dali::PixelData result;
90956
90957   if (!jarg1) {
90958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90959     return 0;
90960   }
90961   std::string arg1_str(jarg1);
90962   arg1 = &arg1_str;
90963   argp2 = (Dali::ImageDimensions *)jarg2;
90964   if (!argp2) {
90965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90966     return 0;
90967   }
90968   arg2 = *argp2;
90969   {
90970     try {
90971       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
90972     } catch (std::out_of_range& e) {
90973       {
90974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90975       };
90976     } catch (std::exception& e) {
90977       {
90978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (Dali::DaliException e) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90983       };
90984     } catch (...) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90987       };
90988     }
90989   }
90990
90991   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90992
90993   //argout typemap for const std::string&
90994
90995   return jresult;
90996 }
90997
90998
90999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91000   void * jresult ;
91001   std::string *arg1 = 0 ;
91002   Dali::ImageDimensions arg2 ;
91003   Dali::FittingMode::Type arg3 ;
91004   Dali::SamplingMode::Type arg4 ;
91005   bool arg5 ;
91006   Dali::ImageDimensions *argp2 ;
91007   Dali::PixelData result;
91008
91009   if (!jarg1) {
91010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91011     return 0;
91012   }
91013   std::string arg1_str(jarg1);
91014   arg1 = &arg1_str;
91015   argp2 = (Dali::ImageDimensions *)jarg2;
91016   if (!argp2) {
91017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91018     return 0;
91019   }
91020   arg2 = *argp2;
91021   arg3 = (Dali::FittingMode::Type)jarg3;
91022   arg4 = (Dali::SamplingMode::Type)jarg4;
91023   arg5 = jarg5 ? true : false;
91024   {
91025     try {
91026       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91027     } catch (std::out_of_range& e) {
91028       {
91029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91030       };
91031     } catch (std::exception& e) {
91032       {
91033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91034       };
91035     } catch (Dali::DaliException e) {
91036       {
91037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91038       };
91039     } catch (...) {
91040       {
91041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91042       };
91043     }
91044   }
91045
91046   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91047
91048   //argout typemap for const std::string&
91049
91050   return jresult;
91051 }
91052
91053
91054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91055   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91056
91057   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91058   {
91059     try {
91060       delete arg1;
91061     } catch (std::out_of_range& e) {
91062       {
91063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91064       };
91065     } catch (std::exception& e) {
91066       {
91067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91068       };
91069     } catch (Dali::DaliException e) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91072       };
91073     } catch (...) {
91074       {
91075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91076       };
91077     }
91078   }
91079
91080 }
91081
91082
91083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91084   void * jresult ;
91085   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91086   Dali::Actor arg2 ;
91087   Dali::Actor arg3 ;
91088   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91089   Dali::Actor *argp2 ;
91090   Dali::Actor *argp3 ;
91091   Dali::Actor result;
91092
91093   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91094   argp2 = (Dali::Actor *)jarg2;
91095   if (!argp2) {
91096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91097     return 0;
91098   }
91099   arg2 = *argp2;
91100   argp3 = (Dali::Actor *)jarg3;
91101   if (!argp3) {
91102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91103     return 0;
91104   }
91105   arg3 = *argp3;
91106   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91107   {
91108     try {
91109       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91110     } catch (std::out_of_range& e) {
91111       {
91112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91113       };
91114     } catch (std::exception& e) {
91115       {
91116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91117       };
91118     } catch (Dali::DaliException e) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91121       };
91122     } catch (...) {
91123       {
91124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91125       };
91126     }
91127   }
91128
91129   jresult = new Dali::Actor((const Dali::Actor &)result);
91130   return jresult;
91131 }
91132
91133
91134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91135   void * jresult ;
91136   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91137
91138   {
91139     try {
91140       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91141     } catch (std::out_of_range& e) {
91142       {
91143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (std::exception& e) {
91146       {
91147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91148       };
91149     } catch (Dali::DaliException e) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91152       };
91153     } catch (...) {
91154       {
91155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91156       };
91157     }
91158   }
91159
91160   jresult = (void *)result;
91161   return jresult;
91162 }
91163
91164
91165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91166   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91167   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91168   if (director) {
91169     director->swig_connect_director(callback0);
91170   }
91171 }
91172
91173
91174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91175   KeyboardFocusManager arg1 ;
91176   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91177   KeyboardFocusManager *argp1 ;
91178
91179   argp1 = (KeyboardFocusManager *)jarg1;
91180   if (!argp1) {
91181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91182     return ;
91183   }
91184   arg1 = *argp1;
91185   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91186   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91187   {
91188     try {
91189       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91190     } catch (std::out_of_range& e) {
91191       {
91192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91193       };
91194     } catch (std::exception& e) {
91195       {
91196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91197       };
91198     } catch (Dali::DaliException e) {
91199       {
91200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91201       };
91202     } catch (...) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91205       };
91206     }
91207   }
91208
91209 }
91210
91211
91212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91213   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91214
91215   arg1 = (std::vector< unsigned int > *)jarg1;
91216   {
91217     try {
91218       (arg1)->clear();
91219     } catch (std::out_of_range& e) {
91220       {
91221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91222       };
91223     } catch (std::exception& e) {
91224       {
91225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91226       };
91227     } catch (Dali::DaliException e) {
91228       {
91229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91230       };
91231     } catch (...) {
91232       {
91233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91234       };
91235     }
91236   }
91237
91238 }
91239
91240
91241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91242   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91243   unsigned int *arg2 = 0 ;
91244   unsigned int temp2 ;
91245
91246   arg1 = (std::vector< unsigned int > *)jarg1;
91247   temp2 = (unsigned int)jarg2;
91248   arg2 = &temp2;
91249   {
91250     try {
91251       (arg1)->push_back((unsigned int const &)*arg2);
91252     } catch (std::out_of_range& e) {
91253       {
91254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (std::exception& e) {
91257       {
91258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91259       };
91260     } catch (Dali::DaliException e) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91263       };
91264     } catch (...) {
91265       {
91266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91267       };
91268     }
91269   }
91270
91271 }
91272
91273
91274 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91275   unsigned long jresult ;
91276   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91277   std::vector< unsigned int >::size_type result;
91278
91279   arg1 = (std::vector< unsigned int > *)jarg1;
91280   {
91281     try {
91282       result = ((std::vector< unsigned int > const *)arg1)->size();
91283     } catch (std::out_of_range& e) {
91284       {
91285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91286       };
91287     } catch (std::exception& e) {
91288       {
91289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91290       };
91291     } catch (Dali::DaliException e) {
91292       {
91293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91294       };
91295     } catch (...) {
91296       {
91297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91298       };
91299     }
91300   }
91301
91302   jresult = (unsigned long)result;
91303   return jresult;
91304 }
91305
91306
91307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91308   unsigned long jresult ;
91309   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91310   std::vector< unsigned int >::size_type result;
91311
91312   arg1 = (std::vector< unsigned int > *)jarg1;
91313   {
91314     try {
91315       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91316     } catch (std::out_of_range& e) {
91317       {
91318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (std::exception& e) {
91321       {
91322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91323       };
91324     } catch (Dali::DaliException e) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91327       };
91328     } catch (...) {
91329       {
91330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91331       };
91332     }
91333   }
91334
91335   jresult = (unsigned long)result;
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91341   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91342   std::vector< unsigned int >::size_type arg2 ;
91343
91344   arg1 = (std::vector< unsigned int > *)jarg1;
91345   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91346   {
91347     try {
91348       (arg1)->reserve(arg2);
91349     } catch (std::out_of_range& e) {
91350       {
91351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91352       };
91353     } catch (std::exception& e) {
91354       {
91355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91356       };
91357     } catch (Dali::DaliException e) {
91358       {
91359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91360       };
91361     } catch (...) {
91362       {
91363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91364       };
91365     }
91366   }
91367
91368 }
91369
91370
91371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91372   void * jresult ;
91373   std::vector< unsigned int > *result = 0 ;
91374
91375   {
91376     try {
91377       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91378     } catch (std::out_of_range& e) {
91379       {
91380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91381       };
91382     } catch (std::exception& e) {
91383       {
91384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91385       };
91386     } catch (Dali::DaliException e) {
91387       {
91388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91389       };
91390     } catch (...) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91393       };
91394     }
91395   }
91396
91397   jresult = (void *)result;
91398   return jresult;
91399 }
91400
91401
91402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91403   void * jresult ;
91404   std::vector< unsigned int > *arg1 = 0 ;
91405   std::vector< unsigned int > *result = 0 ;
91406
91407   arg1 = (std::vector< unsigned int > *)jarg1;
91408   if (!arg1) {
91409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91410     return 0;
91411   }
91412   {
91413     try {
91414       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91415     } catch (std::out_of_range& e) {
91416       {
91417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91418       };
91419     } catch (std::exception& e) {
91420       {
91421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91422       };
91423     } catch (Dali::DaliException e) {
91424       {
91425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91426       };
91427     } catch (...) {
91428       {
91429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91430       };
91431     }
91432   }
91433
91434   jresult = (void *)result;
91435   return jresult;
91436 }
91437
91438
91439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91440   void * jresult ;
91441   int arg1 ;
91442   std::vector< unsigned int > *result = 0 ;
91443
91444   arg1 = (int)jarg1;
91445   {
91446     try {
91447       try {
91448         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91449       }
91450       catch(std::out_of_range &_e) {
91451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91452         return 0;
91453       }
91454
91455     } catch (std::out_of_range& e) {
91456       {
91457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (std::exception& e) {
91460       {
91461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91462       };
91463     } catch (Dali::DaliException e) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91466       };
91467     } catch (...) {
91468       {
91469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91470       };
91471     }
91472   }
91473
91474   jresult = (void *)result;
91475   return jresult;
91476 }
91477
91478
91479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91480   unsigned int jresult ;
91481   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91482   int arg2 ;
91483   unsigned int result;
91484
91485   arg1 = (std::vector< unsigned int > *)jarg1;
91486   arg2 = (int)jarg2;
91487   {
91488     try {
91489       try {
91490         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91491       }
91492       catch(std::out_of_range &_e) {
91493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91494         return 0;
91495       }
91496
91497     } catch (std::out_of_range& e) {
91498       {
91499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91500       };
91501     } catch (std::exception& e) {
91502       {
91503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91504       };
91505     } catch (Dali::DaliException e) {
91506       {
91507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91508       };
91509     } catch (...) {
91510       {
91511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91512       };
91513     }
91514   }
91515
91516   jresult = result;
91517   return jresult;
91518 }
91519
91520
91521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91522   unsigned int jresult ;
91523   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91524   int arg2 ;
91525   unsigned int *result = 0 ;
91526
91527   arg1 = (std::vector< unsigned int > *)jarg1;
91528   arg2 = (int)jarg2;
91529   {
91530     try {
91531       try {
91532         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91533       }
91534       catch(std::out_of_range &_e) {
91535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91536         return 0;
91537       }
91538
91539     } catch (std::out_of_range& e) {
91540       {
91541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91542       };
91543     } catch (std::exception& e) {
91544       {
91545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91546       };
91547     } catch (Dali::DaliException e) {
91548       {
91549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91550       };
91551     } catch (...) {
91552       {
91553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91554       };
91555     }
91556   }
91557
91558   jresult = *result;
91559   return jresult;
91560 }
91561
91562
91563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91564   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91565   int arg2 ;
91566   unsigned int *arg3 = 0 ;
91567   unsigned int temp3 ;
91568
91569   arg1 = (std::vector< unsigned int > *)jarg1;
91570   arg2 = (int)jarg2;
91571   temp3 = (unsigned int)jarg3;
91572   arg3 = &temp3;
91573   {
91574     try {
91575       try {
91576         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91577       }
91578       catch(std::out_of_range &_e) {
91579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91580         return ;
91581       }
91582
91583     } catch (std::out_of_range& e) {
91584       {
91585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91586       };
91587     } catch (std::exception& e) {
91588       {
91589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91590       };
91591     } catch (Dali::DaliException e) {
91592       {
91593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91594       };
91595     } catch (...) {
91596       {
91597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91598       };
91599     }
91600   }
91601
91602 }
91603
91604
91605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91607   std::vector< unsigned int > *arg2 = 0 ;
91608
91609   arg1 = (std::vector< unsigned int > *)jarg1;
91610   arg2 = (std::vector< unsigned int > *)jarg2;
91611   if (!arg2) {
91612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91613     return ;
91614   }
91615   {
91616     try {
91617       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91618     } catch (std::out_of_range& e) {
91619       {
91620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91621       };
91622     } catch (std::exception& e) {
91623       {
91624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91625       };
91626     } catch (Dali::DaliException e) {
91627       {
91628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91629       };
91630     } catch (...) {
91631       {
91632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91633       };
91634     }
91635   }
91636
91637 }
91638
91639
91640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91641   void * jresult ;
91642   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91643   int arg2 ;
91644   int arg3 ;
91645   std::vector< unsigned int > *result = 0 ;
91646
91647   arg1 = (std::vector< unsigned int > *)jarg1;
91648   arg2 = (int)jarg2;
91649   arg3 = (int)jarg3;
91650   {
91651     try {
91652       try {
91653         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91654       }
91655       catch(std::out_of_range &_e) {
91656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91657         return 0;
91658       }
91659       catch(std::invalid_argument &_e) {
91660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91661         return 0;
91662       }
91663
91664     } catch (std::out_of_range& e) {
91665       {
91666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91667       };
91668     } catch (std::exception& e) {
91669       {
91670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91671       };
91672     } catch (Dali::DaliException e) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91679       };
91680     }
91681   }
91682
91683   jresult = (void *)result;
91684   return jresult;
91685 }
91686
91687
91688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91689   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91690   int arg2 ;
91691   unsigned int *arg3 = 0 ;
91692   unsigned int temp3 ;
91693
91694   arg1 = (std::vector< unsigned int > *)jarg1;
91695   arg2 = (int)jarg2;
91696   temp3 = (unsigned int)jarg3;
91697   arg3 = &temp3;
91698   {
91699     try {
91700       try {
91701         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91702       }
91703       catch(std::out_of_range &_e) {
91704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91705         return ;
91706       }
91707
91708     } catch (std::out_of_range& e) {
91709       {
91710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91711       };
91712     } catch (std::exception& e) {
91713       {
91714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91715       };
91716     } catch (Dali::DaliException e) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91719       };
91720     } catch (...) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91723       };
91724     }
91725   }
91726
91727 }
91728
91729
91730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91731   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91732   int arg2 ;
91733   std::vector< unsigned int > *arg3 = 0 ;
91734
91735   arg1 = (std::vector< unsigned int > *)jarg1;
91736   arg2 = (int)jarg2;
91737   arg3 = (std::vector< unsigned int > *)jarg3;
91738   if (!arg3) {
91739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91740     return ;
91741   }
91742   {
91743     try {
91744       try {
91745         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91746       }
91747       catch(std::out_of_range &_e) {
91748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91749         return ;
91750       }
91751
91752     } catch (std::out_of_range& e) {
91753       {
91754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91755       };
91756     } catch (std::exception& e) {
91757       {
91758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91759       };
91760     } catch (Dali::DaliException e) {
91761       {
91762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91763       };
91764     } catch (...) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91767       };
91768     }
91769   }
91770
91771 }
91772
91773
91774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91775   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91776   int arg2 ;
91777
91778   arg1 = (std::vector< unsigned int > *)jarg1;
91779   arg2 = (int)jarg2;
91780   {
91781     try {
91782       try {
91783         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91784       }
91785       catch(std::out_of_range &_e) {
91786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91787         return ;
91788       }
91789
91790     } catch (std::out_of_range& e) {
91791       {
91792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91793       };
91794     } catch (std::exception& e) {
91795       {
91796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91797       };
91798     } catch (Dali::DaliException e) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91801       };
91802     } catch (...) {
91803       {
91804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91805       };
91806     }
91807   }
91808
91809 }
91810
91811
91812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91813   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91814   int arg2 ;
91815   int arg3 ;
91816
91817   arg1 = (std::vector< unsigned int > *)jarg1;
91818   arg2 = (int)jarg2;
91819   arg3 = (int)jarg3;
91820   {
91821     try {
91822       try {
91823         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91824       }
91825       catch(std::out_of_range &_e) {
91826         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91827         return ;
91828       }
91829       catch(std::invalid_argument &_e) {
91830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91831         return ;
91832       }
91833
91834     } catch (std::out_of_range& e) {
91835       {
91836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91837       };
91838     } catch (std::exception& e) {
91839       {
91840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91841       };
91842     } catch (Dali::DaliException e) {
91843       {
91844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91845       };
91846     } catch (...) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91849       };
91850     }
91851   }
91852
91853 }
91854
91855
91856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
91857   void * jresult ;
91858   unsigned int *arg1 = 0 ;
91859   int arg2 ;
91860   unsigned int temp1 ;
91861   std::vector< unsigned int > *result = 0 ;
91862
91863   temp1 = (unsigned int)jarg1;
91864   arg1 = &temp1;
91865   arg2 = (int)jarg2;
91866   {
91867     try {
91868       try {
91869         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
91870       }
91871       catch(std::out_of_range &_e) {
91872         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91873         return 0;
91874       }
91875
91876     } catch (std::out_of_range& e) {
91877       {
91878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91879       };
91880     } catch (std::exception& e) {
91881       {
91882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91883       };
91884     } catch (Dali::DaliException e) {
91885       {
91886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91887       };
91888     } catch (...) {
91889       {
91890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91891       };
91892     }
91893   }
91894
91895   jresult = (void *)result;
91896   return jresult;
91897 }
91898
91899
91900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
91901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91902
91903   arg1 = (std::vector< unsigned int > *)jarg1;
91904   {
91905     try {
91906       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
91907     } catch (std::out_of_range& e) {
91908       {
91909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91910       };
91911     } catch (std::exception& e) {
91912       {
91913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91914       };
91915     } catch (Dali::DaliException e) {
91916       {
91917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91918       };
91919     } catch (...) {
91920       {
91921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91922       };
91923     }
91924   }
91925
91926 }
91927
91928
91929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91930   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91931   int arg2 ;
91932   int arg3 ;
91933
91934   arg1 = (std::vector< unsigned int > *)jarg1;
91935   arg2 = (int)jarg2;
91936   arg3 = (int)jarg3;
91937   {
91938     try {
91939       try {
91940         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91941       }
91942       catch(std::out_of_range &_e) {
91943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91944         return ;
91945       }
91946       catch(std::invalid_argument &_e) {
91947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91948         return ;
91949       }
91950
91951     } catch (std::out_of_range& e) {
91952       {
91953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91954       };
91955     } catch (std::exception& e) {
91956       {
91957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91958       };
91959     } catch (Dali::DaliException e) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91962       };
91963     } catch (...) {
91964       {
91965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91966       };
91967     }
91968   }
91969
91970 }
91971
91972
91973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91974   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91975   int arg2 ;
91976   std::vector< unsigned int > *arg3 = 0 ;
91977
91978   arg1 = (std::vector< unsigned int > *)jarg1;
91979   arg2 = (int)jarg2;
91980   arg3 = (std::vector< unsigned int > *)jarg3;
91981   if (!arg3) {
91982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91983     return ;
91984   }
91985   {
91986     try {
91987       try {
91988         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91989       }
91990       catch(std::out_of_range &_e) {
91991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91992         return ;
91993       }
91994
91995     } catch (std::out_of_range& e) {
91996       {
91997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91998       };
91999     } catch (std::exception& e) {
92000       {
92001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92002       };
92003     } catch (Dali::DaliException e) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92006       };
92007     } catch (...) {
92008       {
92009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92010       };
92011     }
92012   }
92013
92014 }
92015
92016
92017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92018   unsigned int jresult ;
92019   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92020   unsigned int *arg2 = 0 ;
92021   unsigned int temp2 ;
92022   bool result;
92023
92024   arg1 = (std::vector< unsigned int > *)jarg1;
92025   temp2 = (unsigned int)jarg2;
92026   arg2 = &temp2;
92027   {
92028     try {
92029       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92030     } catch (std::out_of_range& e) {
92031       {
92032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (std::exception& e) {
92035       {
92036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92037       };
92038     } catch (Dali::DaliException e) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92041       };
92042     } catch (...) {
92043       {
92044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92045       };
92046     }
92047   }
92048
92049   jresult = result;
92050   return jresult;
92051 }
92052
92053
92054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92055   int jresult ;
92056   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92057   unsigned int *arg2 = 0 ;
92058   unsigned int temp2 ;
92059   int result;
92060
92061   arg1 = (std::vector< unsigned int > *)jarg1;
92062   temp2 = (unsigned int)jarg2;
92063   arg2 = &temp2;
92064   {
92065     try {
92066       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92067     } catch (std::out_of_range& e) {
92068       {
92069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92070       };
92071     } catch (std::exception& e) {
92072       {
92073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92074       };
92075     } catch (Dali::DaliException e) {
92076       {
92077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92078       };
92079     } catch (...) {
92080       {
92081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92082       };
92083     }
92084   }
92085
92086   jresult = result;
92087   return jresult;
92088 }
92089
92090
92091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92092   int jresult ;
92093   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92094   unsigned int *arg2 = 0 ;
92095   unsigned int temp2 ;
92096   int result;
92097
92098   arg1 = (std::vector< unsigned int > *)jarg1;
92099   temp2 = (unsigned int)jarg2;
92100   arg2 = &temp2;
92101   {
92102     try {
92103       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92111       };
92112     } catch (Dali::DaliException e) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92115       };
92116     } catch (...) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92119       };
92120     }
92121   }
92122
92123   jresult = result;
92124   return jresult;
92125 }
92126
92127
92128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92129   unsigned int jresult ;
92130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92131   unsigned int *arg2 = 0 ;
92132   unsigned int temp2 ;
92133   bool result;
92134
92135   arg1 = (std::vector< unsigned int > *)jarg1;
92136   temp2 = (unsigned int)jarg2;
92137   arg2 = &temp2;
92138   {
92139     try {
92140       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92141     } catch (std::out_of_range& e) {
92142       {
92143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92144       };
92145     } catch (std::exception& e) {
92146       {
92147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92148       };
92149     } catch (Dali::DaliException e) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92152       };
92153     } catch (...) {
92154       {
92155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92156       };
92157     }
92158   }
92159
92160   jresult = result;
92161   return jresult;
92162 }
92163
92164
92165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92166   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92167
92168   arg1 = (std::vector< unsigned int > *)jarg1;
92169   {
92170     try {
92171       delete arg1;
92172     } catch (std::out_of_range& e) {
92173       {
92174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92175       };
92176     } catch (std::exception& e) {
92177       {
92178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92179       };
92180     } catch (Dali::DaliException e) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92183       };
92184     } catch (...) {
92185       {
92186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92187       };
92188     }
92189   }
92190
92191 }
92192
92193
92194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92195   void * jresult ;
92196   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92197
92198   {
92199     try {
92200       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92201     } catch (std::out_of_range& e) {
92202       {
92203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92204       };
92205     } catch (std::exception& e) {
92206       {
92207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92208       };
92209     } catch (Dali::DaliException e) {
92210       {
92211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92212       };
92213     } catch (...) {
92214       {
92215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92216       };
92217     }
92218   }
92219
92220   jresult = (void *)result;
92221   return jresult;
92222 }
92223
92224
92225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92226   void * jresult ;
92227   unsigned int arg1 ;
92228   Dali::Actor arg2 ;
92229   Dali::Actor *argp2 ;
92230   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92231
92232   arg1 = (unsigned int)jarg1;
92233   argp2 = (Dali::Actor *)jarg2;
92234   if (!argp2) {
92235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92236     return 0;
92237   }
92238   arg2 = *argp2;
92239   {
92240     try {
92241       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92242     } catch (std::out_of_range& e) {
92243       {
92244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (std::exception& e) {
92247       {
92248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92249       };
92250     } catch (Dali::DaliException e) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92253       };
92254     } catch (...) {
92255       {
92256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92257       };
92258     }
92259   }
92260
92261   jresult = (void *)result;
92262   return jresult;
92263 }
92264
92265
92266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92267   void * jresult ;
92268   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92269   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92270
92271   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92272   if (!arg1) {
92273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92274     return 0;
92275   }
92276   {
92277     try {
92278       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92279     } catch (std::out_of_range& e) {
92280       {
92281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92282       };
92283     } catch (std::exception& e) {
92284       {
92285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92286       };
92287     } catch (Dali::DaliException e) {
92288       {
92289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92290       };
92291     } catch (...) {
92292       {
92293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92294       };
92295     }
92296   }
92297
92298   jresult = (void *)result;
92299   return jresult;
92300 }
92301
92302
92303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92304   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92305   unsigned int arg2 ;
92306
92307   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92308   arg2 = (unsigned int)jarg2;
92309   if (arg1) (arg1)->first = arg2;
92310 }
92311
92312
92313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92314   unsigned int jresult ;
92315   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92316   unsigned int result;
92317
92318   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92319   result = (unsigned int) ((arg1)->first);
92320   jresult = result;
92321   return jresult;
92322 }
92323
92324
92325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92326   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92327   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92328
92329   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92330   arg2 = (Dali::Actor *)jarg2;
92331   if (arg1) (arg1)->second = *arg2;
92332 }
92333
92334
92335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92336   void * jresult ;
92337   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92338   Dali::Actor *result = 0 ;
92339
92340   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92341   result = (Dali::Actor *)& ((arg1)->second);
92342   jresult = (void *)result;
92343   return jresult;
92344 }
92345
92346
92347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92348   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92349
92350   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92351   {
92352     try {
92353       delete arg1;
92354     } catch (std::out_of_range& e) {
92355       {
92356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92357       };
92358     } catch (std::exception& e) {
92359       {
92360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92361       };
92362     } catch (Dali::DaliException e) {
92363       {
92364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92369       };
92370     }
92371   }
92372
92373 }
92374
92375
92376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92377   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92378
92379   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92380   {
92381     try {
92382       (arg1)->clear();
92383     } catch (std::out_of_range& e) {
92384       {
92385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92386       };
92387     } catch (std::exception& e) {
92388       {
92389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92390       };
92391     } catch (Dali::DaliException e) {
92392       {
92393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92394       };
92395     } catch (...) {
92396       {
92397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92398       };
92399     }
92400   }
92401
92402 }
92403
92404
92405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92406   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92407   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92408
92409   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92410   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92411   if (!arg2) {
92412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92413     return ;
92414   }
92415   {
92416     try {
92417       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92418     } catch (std::out_of_range& e) {
92419       {
92420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92421       };
92422     } catch (std::exception& e) {
92423       {
92424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92425       };
92426     } catch (Dali::DaliException e) {
92427       {
92428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92429       };
92430     } catch (...) {
92431       {
92432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92433       };
92434     }
92435   }
92436
92437 }
92438
92439
92440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92441   unsigned long jresult ;
92442   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92443   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92444
92445   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92446   {
92447     try {
92448       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92449     } catch (std::out_of_range& e) {
92450       {
92451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92452       };
92453     } catch (std::exception& e) {
92454       {
92455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92456       };
92457     } catch (Dali::DaliException e) {
92458       {
92459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92460       };
92461     } catch (...) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92464       };
92465     }
92466   }
92467
92468   jresult = (unsigned long)result;
92469   return jresult;
92470 }
92471
92472
92473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92474   unsigned long jresult ;
92475   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92476   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92477
92478   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92479   {
92480     try {
92481       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92482     } catch (std::out_of_range& e) {
92483       {
92484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92485       };
92486     } catch (std::exception& e) {
92487       {
92488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92489       };
92490     } catch (Dali::DaliException e) {
92491       {
92492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92493       };
92494     } catch (...) {
92495       {
92496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92497       };
92498     }
92499   }
92500
92501   jresult = (unsigned long)result;
92502   return jresult;
92503 }
92504
92505
92506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92507   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92508   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92509
92510   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92511   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92512   {
92513     try {
92514       (arg1)->reserve(arg2);
92515     } catch (std::out_of_range& e) {
92516       {
92517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92518       };
92519     } catch (std::exception& e) {
92520       {
92521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92522       };
92523     } catch (Dali::DaliException e) {
92524       {
92525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92526       };
92527     } catch (...) {
92528       {
92529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92530       };
92531     }
92532   }
92533
92534 }
92535
92536
92537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92538   void * jresult ;
92539   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92540
92541   {
92542     try {
92543       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92551       };
92552     } catch (Dali::DaliException e) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92555       };
92556     } catch (...) {
92557       {
92558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92559       };
92560     }
92561   }
92562
92563   jresult = (void *)result;
92564   return jresult;
92565 }
92566
92567
92568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92569   void * jresult ;
92570   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92571   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92572
92573   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92574   if (!arg1) {
92575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92576     return 0;
92577   }
92578   {
92579     try {
92580       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);
92581     } catch (std::out_of_range& e) {
92582       {
92583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92584       };
92585     } catch (std::exception& e) {
92586       {
92587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92588       };
92589     } catch (Dali::DaliException e) {
92590       {
92591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92592       };
92593     } catch (...) {
92594       {
92595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92596       };
92597     }
92598   }
92599
92600   jresult = (void *)result;
92601   return jresult;
92602 }
92603
92604
92605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92606   void * jresult ;
92607   int arg1 ;
92608   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92609
92610   arg1 = (int)jarg1;
92611   {
92612     try {
92613       try {
92614         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);
92615       }
92616       catch(std::out_of_range &_e) {
92617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92618         return 0;
92619       }
92620
92621     } catch (std::out_of_range& e) {
92622       {
92623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92624       };
92625     } catch (std::exception& e) {
92626       {
92627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92628       };
92629     } catch (Dali::DaliException e) {
92630       {
92631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92632       };
92633     } catch (...) {
92634       {
92635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92636       };
92637     }
92638   }
92639
92640   jresult = (void *)result;
92641   return jresult;
92642 }
92643
92644
92645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92646   void * jresult ;
92647   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92648   int arg2 ;
92649   std::pair< unsigned int,Dali::Actor > result;
92650
92651   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92652   arg2 = (int)jarg2;
92653   {
92654     try {
92655       try {
92656         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92657       }
92658       catch(std::out_of_range &_e) {
92659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92660         return 0;
92661       }
92662
92663     } catch (std::out_of_range& e) {
92664       {
92665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92666       };
92667     } catch (std::exception& e) {
92668       {
92669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92670       };
92671     } catch (Dali::DaliException e) {
92672       {
92673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92674       };
92675     } catch (...) {
92676       {
92677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92678       };
92679     }
92680   }
92681
92682   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92683   return jresult;
92684 }
92685
92686
92687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92688   void * jresult ;
92689   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92690   int arg2 ;
92691   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92692
92693   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92694   arg2 = (int)jarg2;
92695   {
92696     try {
92697       try {
92698         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92699       }
92700       catch(std::out_of_range &_e) {
92701         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92702         return 0;
92703       }
92704
92705     } catch (std::out_of_range& e) {
92706       {
92707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92708       };
92709     } catch (std::exception& e) {
92710       {
92711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92712       };
92713     } catch (Dali::DaliException e) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92716       };
92717     } catch (...) {
92718       {
92719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92720       };
92721     }
92722   }
92723
92724   jresult = (void *)result;
92725   return jresult;
92726 }
92727
92728
92729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92730   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92731   int arg2 ;
92732   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92733
92734   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92735   arg2 = (int)jarg2;
92736   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92737   if (!arg3) {
92738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92739     return ;
92740   }
92741   {
92742     try {
92743       try {
92744         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);
92745       }
92746       catch(std::out_of_range &_e) {
92747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92748         return ;
92749       }
92750
92751     } catch (std::out_of_range& e) {
92752       {
92753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92754       };
92755     } catch (std::exception& e) {
92756       {
92757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92758       };
92759     } catch (Dali::DaliException e) {
92760       {
92761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92762       };
92763     } catch (...) {
92764       {
92765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92766       };
92767     }
92768   }
92769
92770 }
92771
92772
92773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92774   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92776
92777   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92778   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92779   if (!arg2) {
92780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92781     return ;
92782   }
92783   {
92784     try {
92785       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);
92786     } catch (std::out_of_range& e) {
92787       {
92788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92789       };
92790     } catch (std::exception& e) {
92791       {
92792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92793       };
92794     } catch (Dali::DaliException e) {
92795       {
92796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92797       };
92798     } catch (...) {
92799       {
92800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92801       };
92802     }
92803   }
92804
92805 }
92806
92807
92808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92809   void * jresult ;
92810   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92811   int arg2 ;
92812   int arg3 ;
92813   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92814
92815   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92816   arg2 = (int)jarg2;
92817   arg3 = (int)jarg3;
92818   {
92819     try {
92820       try {
92821         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);
92822       }
92823       catch(std::out_of_range &_e) {
92824         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92825         return 0;
92826       }
92827       catch(std::invalid_argument &_e) {
92828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92829         return 0;
92830       }
92831
92832     } catch (std::out_of_range& e) {
92833       {
92834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92835       };
92836     } catch (std::exception& e) {
92837       {
92838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92839       };
92840     } catch (Dali::DaliException e) {
92841       {
92842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92843       };
92844     } catch (...) {
92845       {
92846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92847       };
92848     }
92849   }
92850
92851   jresult = (void *)result;
92852   return jresult;
92853 }
92854
92855
92856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92857   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92858   int arg2 ;
92859   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92860
92861   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92862   arg2 = (int)jarg2;
92863   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92864   if (!arg3) {
92865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92866     return ;
92867   }
92868   {
92869     try {
92870       try {
92871         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);
92872       }
92873       catch(std::out_of_range &_e) {
92874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92875         return ;
92876       }
92877
92878     } catch (std::out_of_range& e) {
92879       {
92880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (std::exception& e) {
92883       {
92884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92885       };
92886     } catch (Dali::DaliException e) {
92887       {
92888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92889       };
92890     } catch (...) {
92891       {
92892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92893       };
92894     }
92895   }
92896
92897 }
92898
92899
92900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92901   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92902   int arg2 ;
92903   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
92904
92905   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92906   arg2 = (int)jarg2;
92907   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
92908   if (!arg3) {
92909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92910     return ;
92911   }
92912   {
92913     try {
92914       try {
92915         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);
92916       }
92917       catch(std::out_of_range &_e) {
92918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92919         return ;
92920       }
92921
92922     } catch (std::out_of_range& e) {
92923       {
92924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92925       };
92926     } catch (std::exception& e) {
92927       {
92928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92929       };
92930     } catch (Dali::DaliException e) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92933       };
92934     } catch (...) {
92935       {
92936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92937       };
92938     }
92939   }
92940
92941 }
92942
92943
92944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
92945   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92946   int arg2 ;
92947
92948   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92949   arg2 = (int)jarg2;
92950   {
92951     try {
92952       try {
92953         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
92954       }
92955       catch(std::out_of_range &_e) {
92956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92957         return ;
92958       }
92959
92960     } catch (std::out_of_range& e) {
92961       {
92962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92963       };
92964     } catch (std::exception& e) {
92965       {
92966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92967       };
92968     } catch (Dali::DaliException e) {
92969       {
92970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92971       };
92972     } catch (...) {
92973       {
92974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92975       };
92976     }
92977   }
92978
92979 }
92980
92981
92982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92983   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92984   int arg2 ;
92985   int arg3 ;
92986
92987   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92988   arg2 = (int)jarg2;
92989   arg3 = (int)jarg3;
92990   {
92991     try {
92992       try {
92993         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
92994       }
92995       catch(std::out_of_range &_e) {
92996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92997         return ;
92998       }
92999       catch(std::invalid_argument &_e) {
93000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93001         return ;
93002       }
93003
93004     } catch (std::out_of_range& e) {
93005       {
93006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93007       };
93008     } catch (std::exception& e) {
93009       {
93010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93011       };
93012     } catch (Dali::DaliException e) {
93013       {
93014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93015       };
93016     } catch (...) {
93017       {
93018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93019       };
93020     }
93021   }
93022
93023 }
93024
93025
93026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93027   void * jresult ;
93028   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93029   int arg2 ;
93030   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93031
93032   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93033   if (!arg1) {
93034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93035     return 0;
93036   }
93037   arg2 = (int)jarg2;
93038   {
93039     try {
93040       try {
93041         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);
93042       }
93043       catch(std::out_of_range &_e) {
93044         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93045         return 0;
93046       }
93047
93048     } catch (std::out_of_range& e) {
93049       {
93050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93051       };
93052     } catch (std::exception& e) {
93053       {
93054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93055       };
93056     } catch (Dali::DaliException e) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93059       };
93060     } catch (...) {
93061       {
93062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93063       };
93064     }
93065   }
93066
93067   jresult = (void *)result;
93068   return jresult;
93069 }
93070
93071
93072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93073   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93074
93075   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93076   {
93077     try {
93078       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93079     } catch (std::out_of_range& e) {
93080       {
93081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93082       };
93083     } catch (std::exception& e) {
93084       {
93085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93086       };
93087     } catch (Dali::DaliException e) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93090       };
93091     } catch (...) {
93092       {
93093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93094       };
93095     }
93096   }
93097
93098 }
93099
93100
93101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93102   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93103   int arg2 ;
93104   int arg3 ;
93105
93106   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93107   arg2 = (int)jarg2;
93108   arg3 = (int)jarg3;
93109   {
93110     try {
93111       try {
93112         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93113       }
93114       catch(std::out_of_range &_e) {
93115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93116         return ;
93117       }
93118       catch(std::invalid_argument &_e) {
93119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93120         return ;
93121       }
93122
93123     } catch (std::out_of_range& e) {
93124       {
93125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93126       };
93127     } catch (std::exception& e) {
93128       {
93129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93130       };
93131     } catch (Dali::DaliException e) {
93132       {
93133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93134       };
93135     } catch (...) {
93136       {
93137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93138       };
93139     }
93140   }
93141
93142 }
93143
93144
93145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93146   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93147   int arg2 ;
93148   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93149
93150   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93151   arg2 = (int)jarg2;
93152   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93153   if (!arg3) {
93154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93155     return ;
93156   }
93157   {
93158     try {
93159       try {
93160         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);
93161       }
93162       catch(std::out_of_range &_e) {
93163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93164         return ;
93165       }
93166
93167     } catch (std::out_of_range& e) {
93168       {
93169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93170       };
93171     } catch (std::exception& e) {
93172       {
93173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93174       };
93175     } catch (Dali::DaliException e) {
93176       {
93177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93178       };
93179     } catch (...) {
93180       {
93181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93182       };
93183     }
93184   }
93185
93186 }
93187
93188
93189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93190   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93191
93192   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93193   {
93194     try {
93195       delete arg1;
93196     } catch (std::out_of_range& e) {
93197       {
93198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93199       };
93200     } catch (std::exception& e) {
93201       {
93202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93203       };
93204     } catch (Dali::DaliException e) {
93205       {
93206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93207       };
93208     } catch (...) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93211       };
93212     }
93213   }
93214
93215 }
93216
93217
93218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93219   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93220
93221   arg1 = (std::vector< Dali::Actor > *)jarg1;
93222   {
93223     try {
93224       (arg1)->clear();
93225     } catch (std::out_of_range& e) {
93226       {
93227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93228       };
93229     } catch (std::exception& e) {
93230       {
93231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93232       };
93233     } catch (Dali::DaliException e) {
93234       {
93235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93236       };
93237     } catch (...) {
93238       {
93239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93240       };
93241     }
93242   }
93243
93244 }
93245
93246
93247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93248   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93249   Dali::Actor *arg2 = 0 ;
93250
93251   arg1 = (std::vector< Dali::Actor > *)jarg1;
93252   arg2 = (Dali::Actor *)jarg2;
93253   if (!arg2) {
93254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93255     return ;
93256   }
93257   {
93258     try {
93259       (arg1)->push_back((Dali::Actor const &)*arg2);
93260     } catch (std::out_of_range& e) {
93261       {
93262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93263       };
93264     } catch (std::exception& e) {
93265       {
93266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93267       };
93268     } catch (Dali::DaliException e) {
93269       {
93270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93271       };
93272     } catch (...) {
93273       {
93274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93275       };
93276     }
93277   }
93278
93279 }
93280
93281
93282 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93283   unsigned long jresult ;
93284   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93285   std::vector< Dali::Actor >::size_type result;
93286
93287   arg1 = (std::vector< Dali::Actor > *)jarg1;
93288   {
93289     try {
93290       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93291     } catch (std::out_of_range& e) {
93292       {
93293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93294       };
93295     } catch (std::exception& e) {
93296       {
93297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93298       };
93299     } catch (Dali::DaliException e) {
93300       {
93301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93302       };
93303     } catch (...) {
93304       {
93305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93306       };
93307     }
93308   }
93309
93310   jresult = (unsigned long)result;
93311   return jresult;
93312 }
93313
93314
93315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93316   unsigned long jresult ;
93317   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93318   std::vector< Dali::Actor >::size_type result;
93319
93320   arg1 = (std::vector< Dali::Actor > *)jarg1;
93321   {
93322     try {
93323       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93324     } catch (std::out_of_range& e) {
93325       {
93326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (std::exception& e) {
93329       {
93330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93331       };
93332     } catch (Dali::DaliException e) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93335       };
93336     } catch (...) {
93337       {
93338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93339       };
93340     }
93341   }
93342
93343   jresult = (unsigned long)result;
93344   return jresult;
93345 }
93346
93347
93348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93349   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93350   std::vector< Dali::Actor >::size_type arg2 ;
93351
93352   arg1 = (std::vector< Dali::Actor > *)jarg1;
93353   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93354   {
93355     try {
93356       (arg1)->reserve(arg2);
93357     } catch (std::out_of_range& e) {
93358       {
93359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93360       };
93361     } catch (std::exception& e) {
93362       {
93363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93364       };
93365     } catch (Dali::DaliException e) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93368       };
93369     } catch (...) {
93370       {
93371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93372       };
93373     }
93374   }
93375
93376 }
93377
93378
93379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93380   void * jresult ;
93381   std::vector< Dali::Actor > *result = 0 ;
93382
93383   {
93384     try {
93385       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93386     } catch (std::out_of_range& e) {
93387       {
93388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93389       };
93390     } catch (std::exception& e) {
93391       {
93392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93393       };
93394     } catch (Dali::DaliException e) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93397       };
93398     } catch (...) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93401       };
93402     }
93403   }
93404
93405   jresult = (void *)result;
93406   return jresult;
93407 }
93408
93409
93410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93411   void * jresult ;
93412   std::vector< Dali::Actor > *arg1 = 0 ;
93413   std::vector< Dali::Actor > *result = 0 ;
93414
93415   arg1 = (std::vector< Dali::Actor > *)jarg1;
93416   if (!arg1) {
93417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93418     return 0;
93419   }
93420   {
93421     try {
93422       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = (void *)result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93448   void * jresult ;
93449   int arg1 ;
93450   std::vector< Dali::Actor > *result = 0 ;
93451
93452   arg1 = (int)jarg1;
93453   {
93454     try {
93455       try {
93456         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93457       }
93458       catch(std::out_of_range &_e) {
93459         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93460         return 0;
93461       }
93462
93463     } catch (std::out_of_range& e) {
93464       {
93465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93466       };
93467     } catch (std::exception& e) {
93468       {
93469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93470       };
93471     } catch (Dali::DaliException e) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93474       };
93475     } catch (...) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93478       };
93479     }
93480   }
93481
93482   jresult = (void *)result;
93483   return jresult;
93484 }
93485
93486
93487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93488   void * jresult ;
93489   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93490   int arg2 ;
93491   Dali::Actor result;
93492
93493   arg1 = (std::vector< Dali::Actor > *)jarg1;
93494   arg2 = (int)jarg2;
93495   {
93496     try {
93497       try {
93498         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93499       }
93500       catch(std::out_of_range &_e) {
93501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93502         return 0;
93503       }
93504
93505     } catch (std::out_of_range& e) {
93506       {
93507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93508       };
93509     } catch (std::exception& e) {
93510       {
93511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93512       };
93513     } catch (Dali::DaliException e) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93516       };
93517     } catch (...) {
93518       {
93519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93520       };
93521     }
93522   }
93523
93524   jresult = new Dali::Actor((const Dali::Actor &)result);
93525   return jresult;
93526 }
93527
93528
93529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93530   void * jresult ;
93531   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93532   int arg2 ;
93533   Dali::Actor *result = 0 ;
93534
93535   arg1 = (std::vector< Dali::Actor > *)jarg1;
93536   arg2 = (int)jarg2;
93537   {
93538     try {
93539       try {
93540         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93541       }
93542       catch(std::out_of_range &_e) {
93543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93544         return 0;
93545       }
93546
93547     } catch (std::out_of_range& e) {
93548       {
93549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93550       };
93551     } catch (std::exception& e) {
93552       {
93553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93554       };
93555     } catch (Dali::DaliException e) {
93556       {
93557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93558       };
93559     } catch (...) {
93560       {
93561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93562       };
93563     }
93564   }
93565
93566   jresult = (void *)result;
93567   return jresult;
93568 }
93569
93570
93571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93572   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93573   int arg2 ;
93574   Dali::Actor *arg3 = 0 ;
93575
93576   arg1 = (std::vector< Dali::Actor > *)jarg1;
93577   arg2 = (int)jarg2;
93578   arg3 = (Dali::Actor *)jarg3;
93579   if (!arg3) {
93580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93581     return ;
93582   }
93583   {
93584     try {
93585       try {
93586         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93587       }
93588       catch(std::out_of_range &_e) {
93589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93590         return ;
93591       }
93592
93593     } catch (std::out_of_range& e) {
93594       {
93595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93596       };
93597     } catch (std::exception& e) {
93598       {
93599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93600       };
93601     } catch (Dali::DaliException e) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93604       };
93605     } catch (...) {
93606       {
93607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93608       };
93609     }
93610   }
93611
93612 }
93613
93614
93615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93616   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93617   std::vector< Dali::Actor > *arg2 = 0 ;
93618
93619   arg1 = (std::vector< Dali::Actor > *)jarg1;
93620   arg2 = (std::vector< Dali::Actor > *)jarg2;
93621   if (!arg2) {
93622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93623     return ;
93624   }
93625   {
93626     try {
93627       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93628     } catch (std::out_of_range& e) {
93629       {
93630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93631       };
93632     } catch (std::exception& e) {
93633       {
93634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93635       };
93636     } catch (Dali::DaliException e) {
93637       {
93638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93639       };
93640     } catch (...) {
93641       {
93642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93643       };
93644     }
93645   }
93646
93647 }
93648
93649
93650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93651   void * jresult ;
93652   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93653   int arg2 ;
93654   int arg3 ;
93655   std::vector< Dali::Actor > *result = 0 ;
93656
93657   arg1 = (std::vector< Dali::Actor > *)jarg1;
93658   arg2 = (int)jarg2;
93659   arg3 = (int)jarg3;
93660   {
93661     try {
93662       try {
93663         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93664       }
93665       catch(std::out_of_range &_e) {
93666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93667         return 0;
93668       }
93669       catch(std::invalid_argument &_e) {
93670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93671         return 0;
93672       }
93673
93674     } catch (std::out_of_range& e) {
93675       {
93676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93677       };
93678     } catch (std::exception& e) {
93679       {
93680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93681       };
93682     } catch (Dali::DaliException e) {
93683       {
93684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93685       };
93686     } catch (...) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93689       };
93690     }
93691   }
93692
93693   jresult = (void *)result;
93694   return jresult;
93695 }
93696
93697
93698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93699   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93700   int arg2 ;
93701   Dali::Actor *arg3 = 0 ;
93702
93703   arg1 = (std::vector< Dali::Actor > *)jarg1;
93704   arg2 = (int)jarg2;
93705   arg3 = (Dali::Actor *)jarg3;
93706   if (!arg3) {
93707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93708     return ;
93709   }
93710   {
93711     try {
93712       try {
93713         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93714       }
93715       catch(std::out_of_range &_e) {
93716         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93717         return ;
93718       }
93719
93720     } catch (std::out_of_range& e) {
93721       {
93722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93723       };
93724     } catch (std::exception& e) {
93725       {
93726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93727       };
93728     } catch (Dali::DaliException e) {
93729       {
93730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93731       };
93732     } catch (...) {
93733       {
93734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93735       };
93736     }
93737   }
93738
93739 }
93740
93741
93742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93743   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93744   int arg2 ;
93745   std::vector< Dali::Actor > *arg3 = 0 ;
93746
93747   arg1 = (std::vector< Dali::Actor > *)jarg1;
93748   arg2 = (int)jarg2;
93749   arg3 = (std::vector< Dali::Actor > *)jarg3;
93750   if (!arg3) {
93751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93752     return ;
93753   }
93754   {
93755     try {
93756       try {
93757         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93758       }
93759       catch(std::out_of_range &_e) {
93760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93761         return ;
93762       }
93763
93764     } catch (std::out_of_range& e) {
93765       {
93766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93767       };
93768     } catch (std::exception& e) {
93769       {
93770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93771       };
93772     } catch (Dali::DaliException e) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93775       };
93776     } catch (...) {
93777       {
93778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93779       };
93780     }
93781   }
93782
93783 }
93784
93785
93786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93787   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93788   int arg2 ;
93789
93790   arg1 = (std::vector< Dali::Actor > *)jarg1;
93791   arg2 = (int)jarg2;
93792   {
93793     try {
93794       try {
93795         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93796       }
93797       catch(std::out_of_range &_e) {
93798         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93799         return ;
93800       }
93801
93802     } catch (std::out_of_range& e) {
93803       {
93804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93805       };
93806     } catch (std::exception& e) {
93807       {
93808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93809       };
93810     } catch (Dali::DaliException e) {
93811       {
93812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93813       };
93814     } catch (...) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93817       };
93818     }
93819   }
93820
93821 }
93822
93823
93824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93825   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93826   int arg2 ;
93827   int arg3 ;
93828
93829   arg1 = (std::vector< Dali::Actor > *)jarg1;
93830   arg2 = (int)jarg2;
93831   arg3 = (int)jarg3;
93832   {
93833     try {
93834       try {
93835         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93836       }
93837       catch(std::out_of_range &_e) {
93838         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93839         return ;
93840       }
93841       catch(std::invalid_argument &_e) {
93842         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93843         return ;
93844       }
93845
93846     } catch (std::out_of_range& e) {
93847       {
93848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93849       };
93850     } catch (std::exception& e) {
93851       {
93852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93853       };
93854     } catch (Dali::DaliException e) {
93855       {
93856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93857       };
93858     } catch (...) {
93859       {
93860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93861       };
93862     }
93863   }
93864
93865 }
93866
93867
93868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
93869   void * jresult ;
93870   Dali::Actor *arg1 = 0 ;
93871   int arg2 ;
93872   std::vector< Dali::Actor > *result = 0 ;
93873
93874   arg1 = (Dali::Actor *)jarg1;
93875   if (!arg1) {
93876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93877     return 0;
93878   }
93879   arg2 = (int)jarg2;
93880   {
93881     try {
93882       try {
93883         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
93884       }
93885       catch(std::out_of_range &_e) {
93886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93887         return 0;
93888       }
93889
93890     } catch (std::out_of_range& e) {
93891       {
93892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93893       };
93894     } catch (std::exception& e) {
93895       {
93896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93897       };
93898     } catch (Dali::DaliException e) {
93899       {
93900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93901       };
93902     } catch (...) {
93903       {
93904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93905       };
93906     }
93907   }
93908
93909   jresult = (void *)result;
93910   return jresult;
93911 }
93912
93913
93914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
93915   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93916
93917   arg1 = (std::vector< Dali::Actor > *)jarg1;
93918   {
93919     try {
93920       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
93921     } catch (std::out_of_range& e) {
93922       {
93923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93924       };
93925     } catch (std::exception& e) {
93926       {
93927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93928       };
93929     } catch (Dali::DaliException e) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93932       };
93933     } catch (...) {
93934       {
93935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93936       };
93937     }
93938   }
93939
93940 }
93941
93942
93943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93944   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93945   int arg2 ;
93946   int arg3 ;
93947
93948   arg1 = (std::vector< Dali::Actor > *)jarg1;
93949   arg2 = (int)jarg2;
93950   arg3 = (int)jarg3;
93951   {
93952     try {
93953       try {
93954         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93955       }
93956       catch(std::out_of_range &_e) {
93957         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93958         return ;
93959       }
93960       catch(std::invalid_argument &_e) {
93961         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93962         return ;
93963       }
93964
93965     } catch (std::out_of_range& e) {
93966       {
93967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93968       };
93969     } catch (std::exception& e) {
93970       {
93971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93972       };
93973     } catch (Dali::DaliException e) {
93974       {
93975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93976       };
93977     } catch (...) {
93978       {
93979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93980       };
93981     }
93982   }
93983
93984 }
93985
93986
93987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93988   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93989   int arg2 ;
93990   std::vector< Dali::Actor > *arg3 = 0 ;
93991
93992   arg1 = (std::vector< Dali::Actor > *)jarg1;
93993   arg2 = (int)jarg2;
93994   arg3 = (std::vector< Dali::Actor > *)jarg3;
93995   if (!arg3) {
93996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93997     return ;
93998   }
93999   {
94000     try {
94001       try {
94002         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94003       }
94004       catch(std::out_of_range &_e) {
94005         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94006         return ;
94007       }
94008
94009     } catch (std::out_of_range& e) {
94010       {
94011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94012       };
94013     } catch (std::exception& e) {
94014       {
94015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94016       };
94017     } catch (Dali::DaliException e) {
94018       {
94019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94020       };
94021     } catch (...) {
94022       {
94023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94024       };
94025     }
94026   }
94027
94028 }
94029
94030
94031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94032   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94033
94034   arg1 = (std::vector< Dali::Actor > *)jarg1;
94035   {
94036     try {
94037       delete arg1;
94038     } catch (std::out_of_range& e) {
94039       {
94040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94041       };
94042     } catch (std::exception& e) {
94043       {
94044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94045       };
94046     } catch (Dali::DaliException e) {
94047       {
94048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94049       };
94050     } catch (...) {
94051       {
94052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94053       };
94054     }
94055   }
94056
94057 }
94058
94059
94060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94061   unsigned int jresult ;
94062   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94063   bool result;
94064
94065   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94066   {
94067     try {
94068       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94069     } catch (std::out_of_range& e) {
94070       {
94071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94072       };
94073     } catch (std::exception& e) {
94074       {
94075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94076       };
94077     } catch (Dali::DaliException e) {
94078       {
94079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94080       };
94081     } catch (...) {
94082       {
94083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94084       };
94085     }
94086   }
94087
94088   jresult = result;
94089   return jresult;
94090 }
94091
94092
94093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94094   unsigned long jresult ;
94095   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94096   std::size_t result;
94097
94098   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94099   {
94100     try {
94101       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94102     } catch (std::out_of_range& e) {
94103       {
94104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94105       };
94106     } catch (std::exception& e) {
94107       {
94108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94109       };
94110     } catch (Dali::DaliException e) {
94111       {
94112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94113       };
94114     } catch (...) {
94115       {
94116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94117       };
94118     }
94119   }
94120
94121   jresult = (unsigned long)result;
94122   return jresult;
94123 }
94124
94125
94126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94127   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94128   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94129
94130   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94131   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94132   {
94133     try {
94134       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94135     } catch (std::out_of_range& e) {
94136       {
94137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94138       };
94139     } catch (std::exception& e) {
94140       {
94141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94142       };
94143     } catch (Dali::DaliException e) {
94144       {
94145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94146       };
94147     } catch (...) {
94148       {
94149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94150       };
94151     }
94152   }
94153
94154 }
94155
94156
94157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94158   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94159   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94160
94161   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94162   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94163   {
94164     try {
94165       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94166     } catch (std::out_of_range& e) {
94167       {
94168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94169       };
94170     } catch (std::exception& e) {
94171       {
94172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94173       };
94174     } catch (Dali::DaliException e) {
94175       {
94176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94177       };
94178     } catch (...) {
94179       {
94180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94181       };
94182     }
94183   }
94184
94185 }
94186
94187
94188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94189   unsigned int jresult ;
94190   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94191   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94192   bool result;
94193
94194   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94195   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94196   if (!arg2) {
94197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94198     return 0;
94199   }
94200   {
94201     try {
94202       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94203     } catch (std::out_of_range& e) {
94204       {
94205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94206       };
94207     } catch (std::exception& e) {
94208       {
94209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94210       };
94211     } catch (Dali::DaliException e) {
94212       {
94213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94214       };
94215     } catch (...) {
94216       {
94217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94218       };
94219     }
94220   }
94221
94222   jresult = result;
94223   return jresult;
94224 }
94225
94226
94227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94228   void * jresult ;
94229   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94230
94231   {
94232     try {
94233       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94234     } catch (std::out_of_range& e) {
94235       {
94236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94237       };
94238     } catch (std::exception& e) {
94239       {
94240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94241       };
94242     } catch (Dali::DaliException e) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94245       };
94246     } catch (...) {
94247       {
94248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94249       };
94250     }
94251   }
94252
94253   jresult = (void *)result;
94254   return jresult;
94255 }
94256
94257
94258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94259   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94260
94261   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94262   {
94263     try {
94264       delete arg1;
94265     } catch (std::out_of_range& e) {
94266       {
94267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94268       };
94269     } catch (std::exception& e) {
94270       {
94271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94272       };
94273     } catch (Dali::DaliException e) {
94274       {
94275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94276       };
94277     } catch (...) {
94278       {
94279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94280       };
94281     }
94282   }
94283
94284 }
94285
94286
94287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94288   unsigned int jresult ;
94289   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94290   bool result;
94291
94292   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94293   {
94294     try {
94295       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);
94296     } catch (std::out_of_range& e) {
94297       {
94298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94299       };
94300     } catch (std::exception& e) {
94301       {
94302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94303       };
94304     } catch (Dali::DaliException e) {
94305       {
94306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94307       };
94308     } catch (...) {
94309       {
94310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94311       };
94312     }
94313   }
94314
94315   jresult = result;
94316   return jresult;
94317 }
94318
94319
94320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94321   unsigned long jresult ;
94322   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94323   std::size_t result;
94324
94325   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94326   {
94327     try {
94328       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);
94329     } catch (std::out_of_range& e) {
94330       {
94331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94332       };
94333     } catch (std::exception& e) {
94334       {
94335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94336       };
94337     } catch (Dali::DaliException e) {
94338       {
94339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94340       };
94341     } catch (...) {
94342       {
94343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94344       };
94345     }
94346   }
94347
94348   jresult = (unsigned long)result;
94349   return jresult;
94350 }
94351
94352
94353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94354   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94355   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94356
94357   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94358   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94359   {
94360     try {
94361       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94362     } catch (std::out_of_range& e) {
94363       {
94364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94365       };
94366     } catch (std::exception& e) {
94367       {
94368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94369       };
94370     } catch (Dali::DaliException e) {
94371       {
94372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94373       };
94374     } catch (...) {
94375       {
94376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94377       };
94378     }
94379   }
94380
94381 }
94382
94383
94384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94385   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94386   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94387
94388   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94389   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94390   {
94391     try {
94392       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94393     } catch (std::out_of_range& e) {
94394       {
94395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94396       };
94397     } catch (std::exception& e) {
94398       {
94399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94400       };
94401     } catch (Dali::DaliException e) {
94402       {
94403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94404       };
94405     } catch (...) {
94406       {
94407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94408       };
94409     }
94410   }
94411
94412 }
94413
94414
94415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94416   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94417   Dali::Actor arg2 ;
94418   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94419   Dali::Actor *argp2 ;
94420
94421   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94422   argp2 = (Dali::Actor *)jarg2;
94423   if (!argp2) {
94424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94425     return ;
94426   }
94427   arg2 = *argp2;
94428   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94429   {
94430     try {
94431       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94432     } catch (std::out_of_range& e) {
94433       {
94434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94435       };
94436     } catch (std::exception& e) {
94437       {
94438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94439       };
94440     } catch (Dali::DaliException e) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94443       };
94444     } catch (...) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94447       };
94448     }
94449   }
94450
94451 }
94452
94453
94454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94455   void * jresult ;
94456   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94457
94458   {
94459     try {
94460       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94461     } catch (std::out_of_range& e) {
94462       {
94463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94464       };
94465     } catch (std::exception& e) {
94466       {
94467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94468       };
94469     } catch (Dali::DaliException e) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94472       };
94473     } catch (...) {
94474       {
94475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94476       };
94477     }
94478   }
94479
94480   jresult = (void *)result;
94481   return jresult;
94482 }
94483
94484
94485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94486   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94487
94488   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94489   {
94490     try {
94491       delete arg1;
94492     } catch (std::out_of_range& e) {
94493       {
94494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94495       };
94496     } catch (std::exception& e) {
94497       {
94498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94499       };
94500     } catch (Dali::DaliException e) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94503       };
94504     } catch (...) {
94505       {
94506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94507       };
94508     }
94509   }
94510
94511 }
94512
94513
94514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94515   unsigned int jresult ;
94516   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94517   bool result;
94518
94519   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94520   {
94521     try {
94522       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94523     } catch (std::out_of_range& e) {
94524       {
94525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94526       };
94527     } catch (std::exception& e) {
94528       {
94529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94530       };
94531     } catch (Dali::DaliException e) {
94532       {
94533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94534       };
94535     } catch (...) {
94536       {
94537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94538       };
94539     }
94540   }
94541
94542   jresult = result;
94543   return jresult;
94544 }
94545
94546
94547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94548   unsigned long jresult ;
94549   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94550   std::size_t result;
94551
94552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94553   {
94554     try {
94555       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94556     } catch (std::out_of_range& e) {
94557       {
94558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94559       };
94560     } catch (std::exception& e) {
94561       {
94562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94563       };
94564     } catch (Dali::DaliException e) {
94565       {
94566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94567       };
94568     } catch (...) {
94569       {
94570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94571       };
94572     }
94573   }
94574
94575   jresult = (unsigned long)result;
94576   return jresult;
94577 }
94578
94579
94580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94581   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94582   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94583
94584   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94585   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94586   {
94587     try {
94588       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94589     } catch (std::out_of_range& e) {
94590       {
94591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94592       };
94593     } catch (std::exception& e) {
94594       {
94595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94596       };
94597     } catch (Dali::DaliException e) {
94598       {
94599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94600       };
94601     } catch (...) {
94602       {
94603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94604       };
94605     }
94606   }
94607
94608 }
94609
94610
94611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94612   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94613   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94614
94615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94616   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94617   {
94618     try {
94619       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94620     } catch (std::out_of_range& e) {
94621       {
94622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94623       };
94624     } catch (std::exception& e) {
94625       {
94626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94627       };
94628     } catch (Dali::DaliException e) {
94629       {
94630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94631       };
94632     } catch (...) {
94633       {
94634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94635       };
94636     }
94637   }
94638
94639 }
94640
94641
94642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94643   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94644   Dali::Actor arg2 ;
94645   Dali::Actor arg3 ;
94646   Dali::Actor *argp2 ;
94647   Dali::Actor *argp3 ;
94648
94649   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94650   argp2 = (Dali::Actor *)jarg2;
94651   if (!argp2) {
94652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94653     return ;
94654   }
94655   arg2 = *argp2;
94656   argp3 = (Dali::Actor *)jarg3;
94657   if (!argp3) {
94658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94659     return ;
94660   }
94661   arg3 = *argp3;
94662   {
94663     try {
94664       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94665     } catch (std::out_of_range& e) {
94666       {
94667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94668       };
94669     } catch (std::exception& e) {
94670       {
94671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94672       };
94673     } catch (Dali::DaliException e) {
94674       {
94675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94676       };
94677     } catch (...) {
94678       {
94679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94680       };
94681     }
94682   }
94683
94684 }
94685
94686
94687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94688   void * jresult ;
94689   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94690
94691   {
94692     try {
94693       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94694     } catch (std::out_of_range& e) {
94695       {
94696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94697       };
94698     } catch (std::exception& e) {
94699       {
94700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94701       };
94702     } catch (Dali::DaliException e) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94705       };
94706     } catch (...) {
94707       {
94708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94709       };
94710     }
94711   }
94712
94713   jresult = (void *)result;
94714   return jresult;
94715 }
94716
94717
94718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94719   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94720
94721   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94722   {
94723     try {
94724       delete arg1;
94725     } catch (std::out_of_range& e) {
94726       {
94727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94728       };
94729     } catch (std::exception& e) {
94730       {
94731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94732       };
94733     } catch (Dali::DaliException e) {
94734       {
94735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94736       };
94737     } catch (...) {
94738       {
94739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94740       };
94741     }
94742   }
94743
94744 }
94745
94746
94747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94748   unsigned int jresult ;
94749   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94750   bool result;
94751
94752   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94753   {
94754     try {
94755       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94756     } catch (std::out_of_range& e) {
94757       {
94758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94759       };
94760     } catch (std::exception& e) {
94761       {
94762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94763       };
94764     } catch (Dali::DaliException e) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94767       };
94768     } catch (...) {
94769       {
94770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94771       };
94772     }
94773   }
94774
94775   jresult = result;
94776   return jresult;
94777 }
94778
94779
94780 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94781   unsigned long jresult ;
94782   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94783   std::size_t result;
94784
94785   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94786   {
94787     try {
94788       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94789     } catch (std::out_of_range& e) {
94790       {
94791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94792       };
94793     } catch (std::exception& e) {
94794       {
94795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94796       };
94797     } catch (Dali::DaliException e) {
94798       {
94799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94800       };
94801     } catch (...) {
94802       {
94803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94804       };
94805     }
94806   }
94807
94808   jresult = (unsigned long)result;
94809   return jresult;
94810 }
94811
94812
94813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94814   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94815   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94816
94817   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94818   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94819   {
94820     try {
94821       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94822     } catch (std::out_of_range& e) {
94823       {
94824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94825       };
94826     } catch (std::exception& e) {
94827       {
94828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94829       };
94830     } catch (Dali::DaliException e) {
94831       {
94832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94833       };
94834     } catch (...) {
94835       {
94836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94837       };
94838     }
94839   }
94840
94841 }
94842
94843
94844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94845   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94846   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94847
94848   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94849   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94850   {
94851     try {
94852       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94853     } catch (std::out_of_range& e) {
94854       {
94855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94856       };
94857     } catch (std::exception& e) {
94858       {
94859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94860       };
94861     } catch (Dali::DaliException e) {
94862       {
94863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94864       };
94865     } catch (...) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94868       };
94869     }
94870   }
94871
94872 }
94873
94874
94875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
94876   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94877   Dali::Actor arg2 ;
94878   bool arg3 ;
94879   Dali::Actor *argp2 ;
94880
94881   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94882   argp2 = (Dali::Actor *)jarg2;
94883   if (!argp2) {
94884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94885     return ;
94886   }
94887   arg2 = *argp2;
94888   arg3 = jarg3 ? true : false;
94889   {
94890     try {
94891       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
94892     } catch (std::out_of_range& e) {
94893       {
94894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (std::exception& e) {
94897       {
94898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94899       };
94900     } catch (Dali::DaliException e) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94903       };
94904     } catch (...) {
94905       {
94906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94907       };
94908     }
94909   }
94910
94911 }
94912
94913
94914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
94915   void * jresult ;
94916   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
94917
94918   {
94919     try {
94920       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
94921     } catch (std::out_of_range& e) {
94922       {
94923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94924       };
94925     } catch (std::exception& e) {
94926       {
94927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94928       };
94929     } catch (Dali::DaliException e) {
94930       {
94931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94932       };
94933     } catch (...) {
94934       {
94935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94936       };
94937     }
94938   }
94939
94940   jresult = (void *)result;
94941   return jresult;
94942 }
94943
94944
94945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
94946   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94947
94948   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94949   {
94950     try {
94951       delete arg1;
94952     } catch (std::out_of_range& e) {
94953       {
94954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94955       };
94956     } catch (std::exception& e) {
94957       {
94958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94959       };
94960     } catch (Dali::DaliException e) {
94961       {
94962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94963       };
94964     } catch (...) {
94965       {
94966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94967       };
94968     }
94969   }
94970
94971 }
94972
94973
94974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
94975   unsigned int jresult ;
94976   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94977   bool result;
94978
94979   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94980   {
94981     try {
94982       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);
94983     } catch (std::out_of_range& e) {
94984       {
94985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94986       };
94987     } catch (std::exception& e) {
94988       {
94989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94990       };
94991     } catch (Dali::DaliException e) {
94992       {
94993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94994       };
94995     } catch (...) {
94996       {
94997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94998       };
94999     }
95000   }
95001
95002   jresult = result;
95003   return jresult;
95004 }
95005
95006
95007 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95008   unsigned long jresult ;
95009   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95010   std::size_t result;
95011
95012   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95013   {
95014     try {
95015       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);
95016     } catch (std::out_of_range& e) {
95017       {
95018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95019       };
95020     } catch (std::exception& e) {
95021       {
95022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95023       };
95024     } catch (Dali::DaliException e) {
95025       {
95026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95027       };
95028     } catch (...) {
95029       {
95030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95031       };
95032     }
95033   }
95034
95035   jresult = (unsigned long)result;
95036   return jresult;
95037 }
95038
95039
95040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95041   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95042   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95043
95044   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95045   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95046   {
95047     try {
95048       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95049     } catch (std::out_of_range& e) {
95050       {
95051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95052       };
95053     } catch (std::exception& e) {
95054       {
95055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95056       };
95057     } catch (Dali::DaliException e) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95060       };
95061     } catch (...) {
95062       {
95063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95064       };
95065     }
95066   }
95067
95068 }
95069
95070
95071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95072   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95073   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95074
95075   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95076   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95077   {
95078     try {
95079       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95080     } catch (std::out_of_range& e) {
95081       {
95082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95083       };
95084     } catch (std::exception& e) {
95085       {
95086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95087       };
95088     } catch (Dali::DaliException e) {
95089       {
95090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95091       };
95092     } catch (...) {
95093       {
95094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95095       };
95096     }
95097   }
95098
95099 }
95100
95101
95102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95103   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95104   Dali::Toolkit::StyleManager arg2 ;
95105   Dali::StyleChange::Type arg3 ;
95106   Dali::Toolkit::StyleManager *argp2 ;
95107
95108   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95109   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95110   if (!argp2) {
95111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95112     return ;
95113   }
95114   arg2 = *argp2;
95115   arg3 = (Dali::StyleChange::Type)jarg3;
95116   {
95117     try {
95118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95119     } catch (std::out_of_range& e) {
95120       {
95121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95122       };
95123     } catch (std::exception& e) {
95124       {
95125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95126       };
95127     } catch (Dali::DaliException e) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95130       };
95131     } catch (...) {
95132       {
95133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95134       };
95135     }
95136   }
95137
95138 }
95139
95140
95141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95142   void * jresult ;
95143   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95144
95145   {
95146     try {
95147       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95148     } catch (std::out_of_range& e) {
95149       {
95150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95151       };
95152     } catch (std::exception& e) {
95153       {
95154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95155       };
95156     } catch (Dali::DaliException e) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95159       };
95160     } catch (...) {
95161       {
95162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95163       };
95164     }
95165   }
95166
95167   jresult = (void *)result;
95168   return jresult;
95169 }
95170
95171
95172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95173   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95174
95175   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95176   {
95177     try {
95178       delete arg1;
95179     } catch (std::out_of_range& e) {
95180       {
95181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95182       };
95183     } catch (std::exception& e) {
95184       {
95185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95186       };
95187     } catch (Dali::DaliException e) {
95188       {
95189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95190       };
95191     } catch (...) {
95192       {
95193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95194       };
95195     }
95196   }
95197
95198 }
95199
95200
95201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95202   unsigned int jresult ;
95203   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95204   bool result;
95205
95206   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95207   {
95208     try {
95209       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95210     } catch (std::out_of_range& e) {
95211       {
95212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95213       };
95214     } catch (std::exception& e) {
95215       {
95216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (Dali::DaliException e) {
95219       {
95220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95221       };
95222     } catch (...) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95225       };
95226     }
95227   }
95228
95229   jresult = result;
95230   return jresult;
95231 }
95232
95233
95234 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95235   unsigned long jresult ;
95236   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95237   std::size_t result;
95238
95239   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95240   {
95241     try {
95242       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95243     } catch (std::out_of_range& e) {
95244       {
95245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95246       };
95247     } catch (std::exception& e) {
95248       {
95249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95250       };
95251     } catch (Dali::DaliException e) {
95252       {
95253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95254       };
95255     } catch (...) {
95256       {
95257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95258       };
95259     }
95260   }
95261
95262   jresult = (unsigned long)result;
95263   return jresult;
95264 }
95265
95266
95267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95268   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95269   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95270
95271   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95272   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95273   {
95274     try {
95275       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95276     } catch (std::out_of_range& e) {
95277       {
95278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95279       };
95280     } catch (std::exception& e) {
95281       {
95282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95283       };
95284     } catch (Dali::DaliException e) {
95285       {
95286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95287       };
95288     } catch (...) {
95289       {
95290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95291       };
95292     }
95293   }
95294
95295 }
95296
95297
95298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95299   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95300   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95301
95302   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95303   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95304   {
95305     try {
95306       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95307     } catch (std::out_of_range& e) {
95308       {
95309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95310       };
95311     } catch (std::exception& e) {
95312       {
95313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95314       };
95315     } catch (Dali::DaliException e) {
95316       {
95317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95318       };
95319     } catch (...) {
95320       {
95321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95322       };
95323     }
95324   }
95325
95326 }
95327
95328
95329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95330   unsigned int jresult ;
95331   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95332   Dali::Toolkit::Button arg2 ;
95333   Dali::Toolkit::Button *argp2 ;
95334   bool result;
95335
95336   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95337   argp2 = (Dali::Toolkit::Button *)jarg2;
95338   if (!argp2) {
95339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95340     return 0;
95341   }
95342   arg2 = *argp2;
95343   {
95344     try {
95345       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95346     } catch (std::out_of_range& e) {
95347       {
95348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95349       };
95350     } catch (std::exception& e) {
95351       {
95352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95353       };
95354     } catch (Dali::DaliException e) {
95355       {
95356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95357       };
95358     } catch (...) {
95359       {
95360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95361       };
95362     }
95363   }
95364
95365   jresult = result;
95366   return jresult;
95367 }
95368
95369
95370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95371   void * jresult ;
95372   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95373
95374   {
95375     try {
95376       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95377     } catch (std::out_of_range& e) {
95378       {
95379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95380       };
95381     } catch (std::exception& e) {
95382       {
95383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95384       };
95385     } catch (Dali::DaliException e) {
95386       {
95387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95388       };
95389     } catch (...) {
95390       {
95391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95392       };
95393     }
95394   }
95395
95396   jresult = (void *)result;
95397   return jresult;
95398 }
95399
95400
95401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95402   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95403
95404   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95405   {
95406     try {
95407       delete arg1;
95408     } catch (std::out_of_range& e) {
95409       {
95410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95411       };
95412     } catch (std::exception& e) {
95413       {
95414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95415       };
95416     } catch (Dali::DaliException e) {
95417       {
95418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95419       };
95420     } catch (...) {
95421       {
95422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95423       };
95424     }
95425   }
95426
95427 }
95428
95429
95430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95431   unsigned int jresult ;
95432   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95433   bool result;
95434
95435   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95436   {
95437     try {
95438       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95439     } catch (std::out_of_range& e) {
95440       {
95441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95442       };
95443     } catch (std::exception& e) {
95444       {
95445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95446       };
95447     } catch (Dali::DaliException e) {
95448       {
95449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95450       };
95451     } catch (...) {
95452       {
95453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95454       };
95455     }
95456   }
95457
95458   jresult = result;
95459   return jresult;
95460 }
95461
95462
95463 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95464   unsigned long jresult ;
95465   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95466   std::size_t result;
95467
95468   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95469   {
95470     try {
95471       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95472     } catch (std::out_of_range& e) {
95473       {
95474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95475       };
95476     } catch (std::exception& e) {
95477       {
95478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95479       };
95480     } catch (Dali::DaliException e) {
95481       {
95482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95483       };
95484     } catch (...) {
95485       {
95486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95487       };
95488     }
95489   }
95490
95491   jresult = (unsigned long)result;
95492   return jresult;
95493 }
95494
95495
95496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95497   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95498   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95499
95500   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95501   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95502   {
95503     try {
95504       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95505     } catch (std::out_of_range& e) {
95506       {
95507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95508       };
95509     } catch (std::exception& e) {
95510       {
95511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95512       };
95513     } catch (Dali::DaliException e) {
95514       {
95515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95516       };
95517     } catch (...) {
95518       {
95519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95520       };
95521     }
95522   }
95523
95524 }
95525
95526
95527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95528   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95529   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95530
95531   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95532   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95533   {
95534     try {
95535       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95536     } catch (std::out_of_range& e) {
95537       {
95538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95539       };
95540     } catch (std::exception& e) {
95541       {
95542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95543       };
95544     } catch (Dali::DaliException e) {
95545       {
95546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95547       };
95548     } catch (...) {
95549       {
95550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95551       };
95552     }
95553   }
95554
95555 }
95556
95557
95558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95559   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95560   Dali::Toolkit::GaussianBlurView arg2 ;
95561   Dali::Toolkit::GaussianBlurView *argp2 ;
95562
95563   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95564   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95565   if (!argp2) {
95566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95567     return ;
95568   }
95569   arg2 = *argp2;
95570   {
95571     try {
95572       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95573     } catch (std::out_of_range& e) {
95574       {
95575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95576       };
95577     } catch (std::exception& e) {
95578       {
95579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95580       };
95581     } catch (Dali::DaliException e) {
95582       {
95583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95584       };
95585     } catch (...) {
95586       {
95587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95588       };
95589     }
95590   }
95591
95592 }
95593
95594
95595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95596   void * jresult ;
95597   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95598
95599   {
95600     try {
95601       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95602     } catch (std::out_of_range& e) {
95603       {
95604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95605       };
95606     } catch (std::exception& e) {
95607       {
95608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95609       };
95610     } catch (Dali::DaliException e) {
95611       {
95612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95613       };
95614     } catch (...) {
95615       {
95616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95617       };
95618     }
95619   }
95620
95621   jresult = (void *)result;
95622   return jresult;
95623 }
95624
95625
95626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95627   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95628
95629   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95630   {
95631     try {
95632       delete arg1;
95633     } catch (std::out_of_range& e) {
95634       {
95635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95636       };
95637     } catch (std::exception& e) {
95638       {
95639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95640       };
95641     } catch (Dali::DaliException e) {
95642       {
95643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95644       };
95645     } catch (...) {
95646       {
95647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95648       };
95649     }
95650   }
95651
95652 }
95653
95654
95655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95656   unsigned int jresult ;
95657   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95658   bool result;
95659
95660   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95661   {
95662     try {
95663       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);
95664     } catch (std::out_of_range& e) {
95665       {
95666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95667       };
95668     } catch (std::exception& e) {
95669       {
95670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95671       };
95672     } catch (Dali::DaliException e) {
95673       {
95674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95675       };
95676     } catch (...) {
95677       {
95678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95679       };
95680     }
95681   }
95682
95683   jresult = result;
95684   return jresult;
95685 }
95686
95687
95688 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95689   unsigned long jresult ;
95690   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95691   std::size_t result;
95692
95693   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95694   {
95695     try {
95696       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);
95697     } catch (std::out_of_range& e) {
95698       {
95699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95700       };
95701     } catch (std::exception& e) {
95702       {
95703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95704       };
95705     } catch (Dali::DaliException e) {
95706       {
95707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95708       };
95709     } catch (...) {
95710       {
95711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95712       };
95713     }
95714   }
95715
95716   jresult = (unsigned long)result;
95717   return jresult;
95718 }
95719
95720
95721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95722   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95723   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95724
95725   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95726   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95727   {
95728     try {
95729       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95730     } catch (std::out_of_range& e) {
95731       {
95732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95733       };
95734     } catch (std::exception& e) {
95735       {
95736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95737       };
95738     } catch (Dali::DaliException e) {
95739       {
95740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95741       };
95742     } catch (...) {
95743       {
95744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95745       };
95746     }
95747   }
95748
95749 }
95750
95751
95752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95753   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95754   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95755
95756   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95757   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95758   {
95759     try {
95760       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95761     } catch (std::out_of_range& e) {
95762       {
95763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95764       };
95765     } catch (std::exception& e) {
95766       {
95767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95768       };
95769     } catch (Dali::DaliException e) {
95770       {
95771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95772       };
95773     } catch (...) {
95774       {
95775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95776       };
95777     }
95778   }
95779
95780 }
95781
95782
95783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95784   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95785   Dali::Toolkit::PageTurnView arg2 ;
95786   unsigned int arg3 ;
95787   bool arg4 ;
95788   Dali::Toolkit::PageTurnView *argp2 ;
95789
95790   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95791   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95792   if (!argp2) {
95793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95794     return ;
95795   }
95796   arg2 = *argp2;
95797   arg3 = (unsigned int)jarg3;
95798   arg4 = jarg4 ? true : false;
95799   {
95800     try {
95801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95802     } catch (std::out_of_range& e) {
95803       {
95804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95805       };
95806     } catch (std::exception& e) {
95807       {
95808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95809       };
95810     } catch (Dali::DaliException e) {
95811       {
95812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95813       };
95814     } catch (...) {
95815       {
95816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95817       };
95818     }
95819   }
95820
95821 }
95822
95823
95824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95825   void * jresult ;
95826   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95827
95828   {
95829     try {
95830       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95831     } catch (std::out_of_range& e) {
95832       {
95833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95834       };
95835     } catch (std::exception& e) {
95836       {
95837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95838       };
95839     } catch (Dali::DaliException e) {
95840       {
95841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95842       };
95843     } catch (...) {
95844       {
95845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95846       };
95847     }
95848   }
95849
95850   jresult = (void *)result;
95851   return jresult;
95852 }
95853
95854
95855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
95856   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95857
95858   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95859   {
95860     try {
95861       delete arg1;
95862     } catch (std::out_of_range& e) {
95863       {
95864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95865       };
95866     } catch (std::exception& e) {
95867       {
95868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95869       };
95870     } catch (Dali::DaliException e) {
95871       {
95872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95873       };
95874     } catch (...) {
95875       {
95876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95877       };
95878     }
95879   }
95880
95881 }
95882
95883
95884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
95885   unsigned int jresult ;
95886   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95887   bool result;
95888
95889   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95890   {
95891     try {
95892       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95893     } catch (std::out_of_range& e) {
95894       {
95895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (std::exception& e) {
95898       {
95899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95900       };
95901     } catch (Dali::DaliException e) {
95902       {
95903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95904       };
95905     } catch (...) {
95906       {
95907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95908       };
95909     }
95910   }
95911
95912   jresult = result;
95913   return jresult;
95914 }
95915
95916
95917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
95918   unsigned long jresult ;
95919   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95920   std::size_t result;
95921
95922   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95923   {
95924     try {
95925       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95926     } catch (std::out_of_range& e) {
95927       {
95928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95929       };
95930     } catch (std::exception& e) {
95931       {
95932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95933       };
95934     } catch (Dali::DaliException e) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95937       };
95938     } catch (...) {
95939       {
95940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95941       };
95942     }
95943   }
95944
95945   jresult = (unsigned long)result;
95946   return jresult;
95947 }
95948
95949
95950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
95951   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95952   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95953
95954   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95955   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95956   {
95957     try {
95958       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
95959     } catch (std::out_of_range& e) {
95960       {
95961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (std::exception& e) {
95964       {
95965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95966       };
95967     } catch (Dali::DaliException e) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95970       };
95971     } catch (...) {
95972       {
95973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95974       };
95975     }
95976   }
95977
95978 }
95979
95980
95981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
95982   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95983   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95984
95985   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95986   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95987   {
95988     try {
95989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
95990     } catch (std::out_of_range& e) {
95991       {
95992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95993       };
95994     } catch (std::exception& e) {
95995       {
95996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95997       };
95998     } catch (Dali::DaliException e) {
95999       {
96000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96001       };
96002     } catch (...) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96005       };
96006     }
96007   }
96008
96009 }
96010
96011
96012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96013   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96014   Dali::Toolkit::PageTurnView arg2 ;
96015   Dali::Toolkit::PageTurnView *argp2 ;
96016
96017   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96018   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96019   if (!argp2) {
96020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96021     return ;
96022   }
96023   arg2 = *argp2;
96024   {
96025     try {
96026       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96027     } catch (std::out_of_range& e) {
96028       {
96029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96030       };
96031     } catch (std::exception& e) {
96032       {
96033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96034       };
96035     } catch (Dali::DaliException e) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96038       };
96039     } catch (...) {
96040       {
96041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96042       };
96043     }
96044   }
96045
96046 }
96047
96048
96049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96050   void * jresult ;
96051   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96052
96053   {
96054     try {
96055       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96056     } catch (std::out_of_range& e) {
96057       {
96058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96059       };
96060     } catch (std::exception& e) {
96061       {
96062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96063       };
96064     } catch (Dali::DaliException e) {
96065       {
96066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96067       };
96068     } catch (...) {
96069       {
96070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96071       };
96072     }
96073   }
96074
96075   jresult = (void *)result;
96076   return jresult;
96077 }
96078
96079
96080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96081   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96082
96083   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96084   {
96085     try {
96086       delete arg1;
96087     } catch (std::out_of_range& e) {
96088       {
96089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96090       };
96091     } catch (std::exception& e) {
96092       {
96093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96094       };
96095     } catch (Dali::DaliException e) {
96096       {
96097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96098       };
96099     } catch (...) {
96100       {
96101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96102       };
96103     }
96104   }
96105
96106 }
96107
96108
96109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96110   unsigned int jresult ;
96111   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96112   bool result;
96113
96114   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96115   {
96116     try {
96117       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);
96118     } catch (std::out_of_range& e) {
96119       {
96120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96121       };
96122     } catch (std::exception& e) {
96123       {
96124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96125       };
96126     } catch (Dali::DaliException e) {
96127       {
96128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96129       };
96130     } catch (...) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96133       };
96134     }
96135   }
96136
96137   jresult = result;
96138   return jresult;
96139 }
96140
96141
96142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96143   unsigned long jresult ;
96144   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96145   std::size_t result;
96146
96147   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96148   {
96149     try {
96150       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);
96151     } catch (std::out_of_range& e) {
96152       {
96153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96154       };
96155     } catch (std::exception& e) {
96156       {
96157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96158       };
96159     } catch (Dali::DaliException e) {
96160       {
96161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96162       };
96163     } catch (...) {
96164       {
96165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96166       };
96167     }
96168   }
96169
96170   jresult = (unsigned long)result;
96171   return jresult;
96172 }
96173
96174
96175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96176   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96177   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96178
96179   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96180   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96181   {
96182     try {
96183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96184     } catch (std::out_of_range& e) {
96185       {
96186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96187       };
96188     } catch (std::exception& e) {
96189       {
96190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96191       };
96192     } catch (Dali::DaliException e) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96195       };
96196     } catch (...) {
96197       {
96198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96199       };
96200     }
96201   }
96202
96203 }
96204
96205
96206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96207   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96208   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96209
96210   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96211   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96212   {
96213     try {
96214       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96215     } catch (std::out_of_range& e) {
96216       {
96217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96218       };
96219     } catch (std::exception& e) {
96220       {
96221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96222       };
96223     } catch (Dali::DaliException e) {
96224       {
96225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96226       };
96227     } catch (...) {
96228       {
96229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96230       };
96231     }
96232   }
96233
96234 }
96235
96236
96237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96238   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96239   Dali::Toolkit::ProgressBar arg2 ;
96240   float arg3 ;
96241   float arg4 ;
96242   Dali::Toolkit::ProgressBar *argp2 ;
96243
96244   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96245   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96246   if (!argp2) {
96247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96248     return ;
96249   }
96250   arg2 = *argp2;
96251   arg3 = (float)jarg3;
96252   arg4 = (float)jarg4;
96253   {
96254     try {
96255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96256     } catch (std::out_of_range& e) {
96257       {
96258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96259       };
96260     } catch (std::exception& e) {
96261       {
96262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96263       };
96264     } catch (Dali::DaliException e) {
96265       {
96266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96267       };
96268     } catch (...) {
96269       {
96270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96271       };
96272     }
96273   }
96274
96275 }
96276
96277
96278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96279   void * jresult ;
96280   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96281
96282   {
96283     try {
96284       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96285     } catch (std::out_of_range& e) {
96286       {
96287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96288       };
96289     } catch (std::exception& e) {
96290       {
96291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96292       };
96293     } catch (Dali::DaliException e) {
96294       {
96295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96296       };
96297     } catch (...) {
96298       {
96299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96300       };
96301     }
96302   }
96303
96304   jresult = (void *)result;
96305   return jresult;
96306 }
96307
96308
96309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96310   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96311
96312   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96313   {
96314     try {
96315       delete arg1;
96316     } catch (std::out_of_range& e) {
96317       {
96318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96319       };
96320     } catch (std::exception& e) {
96321       {
96322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96323       };
96324     } catch (Dali::DaliException e) {
96325       {
96326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96327       };
96328     } catch (...) {
96329       {
96330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96331       };
96332     }
96333   }
96334
96335 }
96336
96337
96338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96339   unsigned int jresult ;
96340   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96341   bool result;
96342
96343   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96344   {
96345     try {
96346       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);
96347     } catch (std::out_of_range& e) {
96348       {
96349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96350       };
96351     } catch (std::exception& e) {
96352       {
96353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96354       };
96355     } catch (Dali::DaliException e) {
96356       {
96357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96358       };
96359     } catch (...) {
96360       {
96361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96362       };
96363     }
96364   }
96365
96366   jresult = result;
96367   return jresult;
96368 }
96369
96370
96371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96372   unsigned long jresult ;
96373   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96374   std::size_t result;
96375
96376   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96377   {
96378     try {
96379       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);
96380     } catch (std::out_of_range& e) {
96381       {
96382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96383       };
96384     } catch (std::exception& e) {
96385       {
96386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96387       };
96388     } catch (Dali::DaliException e) {
96389       {
96390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96391       };
96392     } catch (...) {
96393       {
96394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96395       };
96396     }
96397   }
96398
96399   jresult = (unsigned long)result;
96400   return jresult;
96401 }
96402
96403
96404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96405   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96406   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96407
96408   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96409   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96410   {
96411     try {
96412       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96413     } catch (std::out_of_range& e) {
96414       {
96415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (std::exception& e) {
96418       {
96419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96420       };
96421     } catch (Dali::DaliException e) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96424       };
96425     } catch (...) {
96426       {
96427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96428       };
96429     }
96430   }
96431
96432 }
96433
96434
96435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96436   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96437   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96438
96439   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96440   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96441   {
96442     try {
96443       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96444     } catch (std::out_of_range& e) {
96445       {
96446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96447       };
96448     } catch (std::exception& e) {
96449       {
96450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96451       };
96452     } catch (Dali::DaliException e) {
96453       {
96454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96455       };
96456     } catch (...) {
96457       {
96458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96459       };
96460     }
96461   }
96462
96463 }
96464
96465
96466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96467   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96468   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96469
96470   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96471   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96472   if (!arg2) {
96473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96474     return ;
96475   }
96476   {
96477     try {
96478       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96479     } catch (std::out_of_range& e) {
96480       {
96481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96482       };
96483     } catch (std::exception& e) {
96484       {
96485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96486       };
96487     } catch (Dali::DaliException e) {
96488       {
96489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96490       };
96491     } catch (...) {
96492       {
96493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96494       };
96495     }
96496   }
96497
96498 }
96499
96500
96501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96502   void * jresult ;
96503   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96504
96505   {
96506     try {
96507       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96508     } catch (std::out_of_range& e) {
96509       {
96510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96511       };
96512     } catch (std::exception& e) {
96513       {
96514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96515       };
96516     } catch (Dali::DaliException e) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96519       };
96520     } catch (...) {
96521       {
96522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96523       };
96524     }
96525   }
96526
96527   jresult = (void *)result;
96528   return jresult;
96529 }
96530
96531
96532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96533   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96534
96535   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96536   {
96537     try {
96538       delete arg1;
96539     } catch (std::out_of_range& e) {
96540       {
96541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96542       };
96543     } catch (std::exception& e) {
96544       {
96545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96546       };
96547     } catch (Dali::DaliException e) {
96548       {
96549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96550       };
96551     } catch (...) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96554       };
96555     }
96556   }
96557
96558 }
96559
96560
96561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96562   unsigned int jresult ;
96563   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96564   bool result;
96565
96566   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96567   {
96568     try {
96569       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96570     } catch (std::out_of_range& e) {
96571       {
96572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96573       };
96574     } catch (std::exception& e) {
96575       {
96576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96577       };
96578     } catch (Dali::DaliException e) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96581       };
96582     } catch (...) {
96583       {
96584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96585       };
96586     }
96587   }
96588
96589   jresult = result;
96590   return jresult;
96591 }
96592
96593
96594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96595   unsigned long jresult ;
96596   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96597   std::size_t result;
96598
96599   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96600   {
96601     try {
96602       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96603     } catch (std::out_of_range& e) {
96604       {
96605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96606       };
96607     } catch (std::exception& e) {
96608       {
96609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96610       };
96611     } catch (Dali::DaliException e) {
96612       {
96613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96614       };
96615     } catch (...) {
96616       {
96617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96618       };
96619     }
96620   }
96621
96622   jresult = (unsigned long)result;
96623   return jresult;
96624 }
96625
96626
96627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96628   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96629   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96630
96631   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96632   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96633   {
96634     try {
96635       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96636     } catch (std::out_of_range& e) {
96637       {
96638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (std::exception& e) {
96641       {
96642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96643       };
96644     } catch (Dali::DaliException e) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96647       };
96648     } catch (...) {
96649       {
96650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96651       };
96652     }
96653   }
96654
96655 }
96656
96657
96658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96659   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96660   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96661
96662   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96663   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96664   {
96665     try {
96666       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96667     } catch (std::out_of_range& e) {
96668       {
96669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96670       };
96671     } catch (std::exception& e) {
96672       {
96673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96674       };
96675     } catch (Dali::DaliException e) {
96676       {
96677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96678       };
96679     } catch (...) {
96680       {
96681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96682       };
96683     }
96684   }
96685
96686 }
96687
96688
96689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96690   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96691   Dali::Vector2 *arg2 = 0 ;
96692
96693   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96694   arg2 = (Dali::Vector2 *)jarg2;
96695   if (!arg2) {
96696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96697     return ;
96698   }
96699   {
96700     try {
96701       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96702     } catch (std::out_of_range& e) {
96703       {
96704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96705       };
96706     } catch (std::exception& e) {
96707       {
96708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96709       };
96710     } catch (Dali::DaliException e) {
96711       {
96712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96713       };
96714     } catch (...) {
96715       {
96716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96717       };
96718     }
96719   }
96720
96721 }
96722
96723
96724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96725   void * jresult ;
96726   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96727
96728   {
96729     try {
96730       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96731     } catch (std::out_of_range& e) {
96732       {
96733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96734       };
96735     } catch (std::exception& e) {
96736       {
96737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96738       };
96739     } catch (Dali::DaliException e) {
96740       {
96741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96742       };
96743     } catch (...) {
96744       {
96745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96746       };
96747     }
96748   }
96749
96750   jresult = (void *)result;
96751   return jresult;
96752 }
96753
96754
96755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96756   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96757
96758   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96759   {
96760     try {
96761       delete arg1;
96762     } catch (std::out_of_range& e) {
96763       {
96764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96765       };
96766     } catch (std::exception& e) {
96767       {
96768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96769       };
96770     } catch (Dali::DaliException e) {
96771       {
96772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96773       };
96774     } catch (...) {
96775       {
96776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96777       };
96778     }
96779   }
96780
96781 }
96782
96783
96784
96785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96786   unsigned int jresult ;
96787   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96788   bool result;
96789
96790   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96791   {
96792     try {
96793       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);
96794     } catch (std::out_of_range& e) {
96795       {
96796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96797       };
96798     } catch (std::exception& e) {
96799       {
96800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96801       };
96802     } catch (Dali::DaliException e) {
96803       {
96804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96805       };
96806     } catch (...) {
96807       {
96808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96809       };
96810     }
96811   }
96812
96813   jresult = result;
96814   return jresult;
96815 }
96816
96817
96818 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96819   unsigned long jresult ;
96820   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96821   std::size_t result;
96822
96823   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96824   {
96825     try {
96826       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);
96827     } catch (std::out_of_range& e) {
96828       {
96829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (std::exception& e) {
96832       {
96833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96834       };
96835     } catch (Dali::DaliException e) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96838       };
96839     } catch (...) {
96840       {
96841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96842       };
96843     }
96844   }
96845
96846   jresult = (unsigned long)result;
96847   return jresult;
96848 }
96849
96850
96851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
96852   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96853   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96854
96855   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96856   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96857   {
96858     try {
96859       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96860     } catch (std::out_of_range& e) {
96861       {
96862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96863       };
96864     } catch (std::exception& e) {
96865       {
96866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96867       };
96868     } catch (Dali::DaliException e) {
96869       {
96870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96871       };
96872     } catch (...) {
96873       {
96874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96875       };
96876     }
96877   }
96878
96879 }
96880
96881
96882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
96883   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96884   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96885
96886   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96887   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96888   {
96889     try {
96890       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96891     } catch (std::out_of_range& e) {
96892       {
96893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96894       };
96895     } catch (std::exception& e) {
96896       {
96897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96898       };
96899     } catch (Dali::DaliException e) {
96900       {
96901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96902       };
96903     } catch (...) {
96904       {
96905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96906       };
96907     }
96908   }
96909
96910 }
96911
96912
96913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96914   unsigned int jresult ;
96915   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96916   Dali::Toolkit::Control arg2 ;
96917   Dali::KeyEvent *arg3 = 0 ;
96918   Dali::Toolkit::Control *argp2 ;
96919   bool result;
96920
96921   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96922   argp2 = (Dali::Toolkit::Control *)jarg2;
96923   if (!argp2) {
96924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96925     return 0;
96926   }
96927   arg2 = *argp2;
96928   arg3 = (Dali::KeyEvent *)jarg3;
96929   if (!arg3) {
96930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
96931     return 0;
96932   }
96933   {
96934     try {
96935       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);
96936     } catch (std::out_of_range& e) {
96937       {
96938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96939       };
96940     } catch (std::exception& e) {
96941       {
96942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96943       };
96944     } catch (Dali::DaliException e) {
96945       {
96946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96947       };
96948     } catch (...) {
96949       {
96950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96951       };
96952     }
96953   }
96954
96955   jresult = result;
96956   return jresult;
96957 }
96958
96959
96960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
96961   void * jresult ;
96962   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
96963
96964   {
96965     try {
96966       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
96967     } catch (std::out_of_range& e) {
96968       {
96969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96970       };
96971     } catch (std::exception& e) {
96972       {
96973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96974       };
96975     } catch (Dali::DaliException e) {
96976       {
96977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96978       };
96979     } catch (...) {
96980       {
96981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96982       };
96983     }
96984   }
96985
96986   jresult = (void *)result;
96987   return jresult;
96988 }
96989
96990
96991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
96992   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96993
96994   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96995   {
96996     try {
96997       delete arg1;
96998     } catch (std::out_of_range& e) {
96999       {
97000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97001       };
97002     } catch (std::exception& e) {
97003       {
97004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97005       };
97006     } catch (Dali::DaliException e) {
97007       {
97008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97009       };
97010     } catch (...) {
97011       {
97012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97013       };
97014     }
97015   }
97016
97017 }
97018
97019
97020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97021   unsigned int jresult ;
97022   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97023   bool result;
97024
97025   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97026   {
97027     try {
97028       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97029     } catch (std::out_of_range& e) {
97030       {
97031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97032       };
97033     } catch (std::exception& e) {
97034       {
97035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97036       };
97037     } catch (Dali::DaliException e) {
97038       {
97039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97040       };
97041     } catch (...) {
97042       {
97043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97044       };
97045     }
97046   }
97047
97048   jresult = result;
97049   return jresult;
97050 }
97051
97052
97053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97054   unsigned long jresult ;
97055   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97056   std::size_t result;
97057
97058   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97059   {
97060     try {
97061       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97062     } catch (std::out_of_range& e) {
97063       {
97064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97065       };
97066     } catch (std::exception& e) {
97067       {
97068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97069       };
97070     } catch (Dali::DaliException e) {
97071       {
97072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97073       };
97074     } catch (...) {
97075       {
97076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97077       };
97078     }
97079   }
97080
97081   jresult = (unsigned long)result;
97082   return jresult;
97083 }
97084
97085
97086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97087   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97088   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97089
97090   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97091   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97092   {
97093     try {
97094       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97095     } catch (std::out_of_range& e) {
97096       {
97097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97098       };
97099     } catch (std::exception& e) {
97100       {
97101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97102       };
97103     } catch (Dali::DaliException e) {
97104       {
97105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97106       };
97107     } catch (...) {
97108       {
97109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97110       };
97111     }
97112   }
97113
97114 }
97115
97116
97117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97118   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97119   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97120
97121   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97122   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97123   {
97124     try {
97125       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97126     } catch (std::out_of_range& e) {
97127       {
97128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97129       };
97130     } catch (std::exception& e) {
97131       {
97132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97133       };
97134     } catch (Dali::DaliException e) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97137       };
97138     } catch (...) {
97139       {
97140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97141       };
97142     }
97143   }
97144
97145 }
97146
97147
97148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97149   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97150   Dali::Toolkit::Control arg2 ;
97151   Dali::Toolkit::Control *argp2 ;
97152
97153   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97154   argp2 = (Dali::Toolkit::Control *)jarg2;
97155   if (!argp2) {
97156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97157     return ;
97158   }
97159   arg2 = *argp2;
97160   {
97161     try {
97162       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97163     } catch (std::out_of_range& e) {
97164       {
97165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97166       };
97167     } catch (std::exception& e) {
97168       {
97169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97170       };
97171     } catch (Dali::DaliException e) {
97172       {
97173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97174       };
97175     } catch (...) {
97176       {
97177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97178       };
97179     }
97180   }
97181
97182 }
97183
97184
97185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97186   void * jresult ;
97187   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97188
97189   {
97190     try {
97191       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97192     } catch (std::out_of_range& e) {
97193       {
97194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (std::exception& e) {
97197       {
97198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97199       };
97200     } catch (Dali::DaliException e) {
97201       {
97202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97203       };
97204     } catch (...) {
97205       {
97206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97207       };
97208     }
97209   }
97210
97211   jresult = (void *)result;
97212   return jresult;
97213 }
97214
97215
97216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97217   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97218
97219   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97220   {
97221     try {
97222       delete arg1;
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97230       };
97231     } catch (Dali::DaliException e) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97234       };
97235     } catch (...) {
97236       {
97237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97238       };
97239     }
97240   }
97241
97242 }
97243
97244
97245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97246   unsigned int jresult ;
97247   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97248   bool result;
97249
97250   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97251   {
97252     try {
97253       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97254     } catch (std::out_of_range& e) {
97255       {
97256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97257       };
97258     } catch (std::exception& e) {
97259       {
97260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97261       };
97262     } catch (Dali::DaliException e) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97265       };
97266     } catch (...) {
97267       {
97268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97269       };
97270     }
97271   }
97272
97273   jresult = result;
97274   return jresult;
97275 }
97276
97277
97278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97279   unsigned long jresult ;
97280   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97281   std::size_t result;
97282
97283   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97284   {
97285     try {
97286       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97287     } catch (std::out_of_range& e) {
97288       {
97289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97290       };
97291     } catch (std::exception& e) {
97292       {
97293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97294       };
97295     } catch (Dali::DaliException e) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97298       };
97299     } catch (...) {
97300       {
97301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97302       };
97303     }
97304   }
97305
97306   jresult = (unsigned long)result;
97307   return jresult;
97308 }
97309
97310
97311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97312   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97313   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97314
97315   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97316   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97317   {
97318     try {
97319       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97320     } catch (std::out_of_range& e) {
97321       {
97322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97323       };
97324     } catch (std::exception& e) {
97325       {
97326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97327       };
97328     } catch (Dali::DaliException e) {
97329       {
97330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97331       };
97332     } catch (...) {
97333       {
97334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97335       };
97336     }
97337   }
97338
97339 }
97340
97341
97342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97343   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97344   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97345
97346   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97347   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97348   {
97349     try {
97350       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97351     } catch (std::out_of_range& e) {
97352       {
97353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97354       };
97355     } catch (std::exception& e) {
97356       {
97357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97358       };
97359     } catch (Dali::DaliException e) {
97360       {
97361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97362       };
97363     } catch (...) {
97364       {
97365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97366       };
97367     }
97368   }
97369
97370 }
97371
97372
97373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97374   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97375   Dali::Toolkit::VideoView *arg2 = 0 ;
97376
97377   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97378   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97379   if (!arg2) {
97380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97381     return ;
97382   }
97383   {
97384     try {
97385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97386     } catch (std::out_of_range& e) {
97387       {
97388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97389       };
97390     } catch (std::exception& e) {
97391       {
97392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97393       };
97394     } catch (Dali::DaliException e) {
97395       {
97396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97397       };
97398     } catch (...) {
97399       {
97400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97401       };
97402     }
97403   }
97404
97405 }
97406
97407
97408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97409   void * jresult ;
97410   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97411
97412   {
97413     try {
97414       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97430       };
97431     }
97432   }
97433
97434   jresult = (void *)result;
97435   return jresult;
97436 }
97437
97438
97439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97440   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97441
97442   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97443   {
97444     try {
97445       delete arg1;
97446     } catch (std::out_of_range& e) {
97447       {
97448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97449       };
97450     } catch (std::exception& e) {
97451       {
97452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97453       };
97454     } catch (Dali::DaliException e) {
97455       {
97456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97457       };
97458     } catch (...) {
97459       {
97460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97461       };
97462     }
97463   }
97464
97465 }
97466
97467
97468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97469   unsigned int jresult ;
97470   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97471   bool result;
97472
97473   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97474   {
97475     try {
97476       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97477     } catch (std::out_of_range& e) {
97478       {
97479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97480       };
97481     } catch (std::exception& e) {
97482       {
97483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97484       };
97485     } catch (Dali::DaliException e) {
97486       {
97487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97488       };
97489     } catch (...) {
97490       {
97491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97492       };
97493     }
97494   }
97495
97496   jresult = result;
97497   return jresult;
97498 }
97499
97500
97501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97502   unsigned long jresult ;
97503   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97504   std::size_t result;
97505
97506   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97507   {
97508     try {
97509       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97510     } catch (std::out_of_range& e) {
97511       {
97512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97513       };
97514     } catch (std::exception& e) {
97515       {
97516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97517       };
97518     } catch (Dali::DaliException e) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97521       };
97522     } catch (...) {
97523       {
97524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97525       };
97526     }
97527   }
97528
97529   jresult = (unsigned long)result;
97530   return jresult;
97531 }
97532
97533
97534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97535   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97536   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97537
97538   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97539   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97540   {
97541     try {
97542       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97543     } catch (std::out_of_range& e) {
97544       {
97545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97546       };
97547     } catch (std::exception& e) {
97548       {
97549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97550       };
97551     } catch (Dali::DaliException e) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97554       };
97555     } catch (...) {
97556       {
97557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97558       };
97559     }
97560   }
97561
97562 }
97563
97564
97565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97566   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97567   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97568
97569   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97570   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97571   {
97572     try {
97573       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97574     } catch (std::out_of_range& e) {
97575       {
97576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97577       };
97578     } catch (std::exception& e) {
97579       {
97580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97581       };
97582     } catch (Dali::DaliException e) {
97583       {
97584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97585       };
97586     } catch (...) {
97587       {
97588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97589       };
97590     }
97591   }
97592
97593 }
97594
97595
97596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97597   unsigned int jresult ;
97598   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97599   Dali::Toolkit::Slider arg2 ;
97600   float arg3 ;
97601   Dali::Toolkit::Slider *argp2 ;
97602   bool result;
97603
97604   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97605   argp2 = (Dali::Toolkit::Slider *)jarg2;
97606   if (!argp2) {
97607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97608     return 0;
97609   }
97610   arg2 = *argp2;
97611   arg3 = (float)jarg3;
97612   {
97613     try {
97614       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97615     } catch (std::out_of_range& e) {
97616       {
97617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97618       };
97619     } catch (std::exception& e) {
97620       {
97621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97622       };
97623     } catch (Dali::DaliException e) {
97624       {
97625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97626       };
97627     } catch (...) {
97628       {
97629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97630       };
97631     }
97632   }
97633
97634   jresult = result;
97635   return jresult;
97636 }
97637
97638
97639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97640   void * jresult ;
97641   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97642
97643   {
97644     try {
97645       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97646     } catch (std::out_of_range& e) {
97647       {
97648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97649       };
97650     } catch (std::exception& e) {
97651       {
97652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97653       };
97654     } catch (Dali::DaliException e) {
97655       {
97656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97657       };
97658     } catch (...) {
97659       {
97660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97661       };
97662     }
97663   }
97664
97665   jresult = (void *)result;
97666   return jresult;
97667 }
97668
97669
97670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97671   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97672
97673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97674   {
97675     try {
97676       delete arg1;
97677     } catch (std::out_of_range& e) {
97678       {
97679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97680       };
97681     } catch (std::exception& e) {
97682       {
97683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97684       };
97685     } catch (Dali::DaliException e) {
97686       {
97687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97692       };
97693     }
97694   }
97695
97696 }
97697
97698
97699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97700   unsigned int jresult ;
97701   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97702   bool result;
97703
97704   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97705   {
97706     try {
97707       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97708     } catch (std::out_of_range& e) {
97709       {
97710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97711       };
97712     } catch (std::exception& e) {
97713       {
97714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97715       };
97716     } catch (Dali::DaliException e) {
97717       {
97718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97719       };
97720     } catch (...) {
97721       {
97722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97723       };
97724     }
97725   }
97726
97727   jresult = result;
97728   return jresult;
97729 }
97730
97731
97732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97733   unsigned long jresult ;
97734   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97735   std::size_t result;
97736
97737   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97738   {
97739     try {
97740       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97741     } catch (std::out_of_range& e) {
97742       {
97743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97744       };
97745     } catch (std::exception& e) {
97746       {
97747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97748       };
97749     } catch (Dali::DaliException e) {
97750       {
97751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97752       };
97753     } catch (...) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97756       };
97757     }
97758   }
97759
97760   jresult = (unsigned long)result;
97761   return jresult;
97762 }
97763
97764
97765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97766   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97767   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97768
97769   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97770   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97771   {
97772     try {
97773       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97774     } catch (std::out_of_range& e) {
97775       {
97776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97777       };
97778     } catch (std::exception& e) {
97779       {
97780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97781       };
97782     } catch (Dali::DaliException e) {
97783       {
97784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97785       };
97786     } catch (...) {
97787       {
97788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97789       };
97790     }
97791   }
97792
97793 }
97794
97795
97796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97797   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97798   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97799
97800   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97801   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97802   {
97803     try {
97804       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97805     } catch (std::out_of_range& e) {
97806       {
97807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97808       };
97809     } catch (std::exception& e) {
97810       {
97811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97812       };
97813     } catch (Dali::DaliException e) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97816       };
97817     } catch (...) {
97818       {
97819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97820       };
97821     }
97822   }
97823
97824 }
97825
97826
97827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97828   unsigned int jresult ;
97829   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97830   Dali::Toolkit::Slider arg2 ;
97831   int arg3 ;
97832   Dali::Toolkit::Slider *argp2 ;
97833   bool result;
97834
97835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97836   argp2 = (Dali::Toolkit::Slider *)jarg2;
97837   if (!argp2) {
97838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97839     return 0;
97840   }
97841   arg2 = *argp2;
97842   arg3 = (int)jarg3;
97843   {
97844     try {
97845       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97846     } catch (std::out_of_range& e) {
97847       {
97848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97849       };
97850     } catch (std::exception& e) {
97851       {
97852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97853       };
97854     } catch (Dali::DaliException e) {
97855       {
97856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97857       };
97858     } catch (...) {
97859       {
97860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97861       };
97862     }
97863   }
97864
97865   jresult = result;
97866   return jresult;
97867 }
97868
97869
97870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
97871   void * jresult ;
97872   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
97873
97874   {
97875     try {
97876       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
97877     } catch (std::out_of_range& e) {
97878       {
97879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97880       };
97881     } catch (std::exception& e) {
97882       {
97883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97884       };
97885     } catch (Dali::DaliException e) {
97886       {
97887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97888       };
97889     } catch (...) {
97890       {
97891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97892       };
97893     }
97894   }
97895
97896   jresult = (void *)result;
97897   return jresult;
97898 }
97899
97900
97901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
97902   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97903
97904   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97905   {
97906     try {
97907       delete arg1;
97908     } catch (std::out_of_range& e) {
97909       {
97910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97911       };
97912     } catch (std::exception& e) {
97913       {
97914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97915       };
97916     } catch (Dali::DaliException e) {
97917       {
97918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97919       };
97920     } catch (...) {
97921       {
97922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97923       };
97924     }
97925   }
97926
97927 }
97928
97929
97930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
97931   void * jresult ;
97932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97933
97934   {
97935     try {
97936       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
97937     } catch (std::out_of_range& e) {
97938       {
97939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97940       };
97941     } catch (std::exception& e) {
97942       {
97943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97944       };
97945     } catch (Dali::DaliException e) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97948       };
97949     } catch (...) {
97950       {
97951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97952       };
97953     }
97954   }
97955
97956   jresult = (void *)result;
97957   return jresult;
97958 }
97959
97960
97961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
97962   void * jresult ;
97963   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
97964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97965
97966   arg1 = (Dali::Toolkit::Ruler *)jarg1;
97967   {
97968     try {
97969       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
97970     } catch (std::out_of_range& e) {
97971       {
97972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97973       };
97974     } catch (std::exception& e) {
97975       {
97976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97977       };
97978     } catch (Dali::DaliException e) {
97979       {
97980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97981       };
97982     } catch (...) {
97983       {
97984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97985       };
97986     }
97987   }
97988
97989   jresult = (void *)result;
97990   return jresult;
97991 }
97992
97993
97994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
97995   void * jresult ;
97996   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
97997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97998
97999   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98000   if (!arg1) {
98001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98002     return 0;
98003   }
98004   {
98005     try {
98006       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98007     } catch (std::out_of_range& e) {
98008       {
98009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98010       };
98011     } catch (std::exception& e) {
98012       {
98013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98014       };
98015     } catch (Dali::DaliException e) {
98016       {
98017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98018       };
98019     } catch (...) {
98020       {
98021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98022       };
98023     }
98024   }
98025
98026   jresult = (void *)result;
98027   return jresult;
98028 }
98029
98030
98031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98033
98034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98035   {
98036     try {
98037       delete arg1;
98038     } catch (std::out_of_range& e) {
98039       {
98040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98041       };
98042     } catch (std::exception& e) {
98043       {
98044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98045       };
98046     } catch (Dali::DaliException e) {
98047       {
98048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98049       };
98050     } catch (...) {
98051       {
98052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98053       };
98054     }
98055   }
98056
98057 }
98058
98059
98060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98061   void * jresult ;
98062   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98063   Dali::Toolkit::Ruler *result = 0 ;
98064
98065   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98066   {
98067     try {
98068       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98069     } catch (std::out_of_range& e) {
98070       {
98071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98072       };
98073     } catch (std::exception& e) {
98074       {
98075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98076       };
98077     } catch (Dali::DaliException e) {
98078       {
98079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98080       };
98081     } catch (...) {
98082       {
98083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98084       };
98085     }
98086   }
98087
98088   jresult = (void *)result;
98089   return jresult;
98090 }
98091
98092
98093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98094   void * jresult ;
98095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98096   Dali::Toolkit::Ruler *result = 0 ;
98097
98098   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98099   {
98100     try {
98101       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98102     } catch (std::out_of_range& e) {
98103       {
98104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98105       };
98106     } catch (std::exception& e) {
98107       {
98108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98109       };
98110     } catch (Dali::DaliException e) {
98111       {
98112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98113       };
98114     } catch (...) {
98115       {
98116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98117       };
98118     }
98119   }
98120
98121   jresult = (void *)result;
98122   return jresult;
98123 }
98124
98125
98126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98127   void * jresult ;
98128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98129   Dali::Toolkit::Ruler *result = 0 ;
98130
98131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98132   {
98133     try {
98134       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98135     } catch (std::out_of_range& e) {
98136       {
98137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98138       };
98139     } catch (std::exception& e) {
98140       {
98141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98142       };
98143     } catch (Dali::DaliException e) {
98144       {
98145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98146       };
98147     } catch (...) {
98148       {
98149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98150       };
98151     }
98152   }
98153
98154   jresult = (void *)result;
98155   return jresult;
98156 }
98157
98158
98159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98160   void * jresult ;
98161   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98162   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98164
98165   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98166   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98167   if (!arg2) {
98168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98169     return 0;
98170   }
98171   {
98172     try {
98173       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98174     } catch (std::out_of_range& e) {
98175       {
98176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98177       };
98178     } catch (std::exception& e) {
98179       {
98180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98181       };
98182     } catch (Dali::DaliException e) {
98183       {
98184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98185       };
98186     } catch (...) {
98187       {
98188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98189       };
98190     }
98191   }
98192
98193   jresult = (void *)result;
98194   return jresult;
98195 }
98196
98197
98198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98199   void * jresult ;
98200   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98201   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98202   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98203
98204   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98205   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98206   {
98207     try {
98208       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98209     } catch (std::out_of_range& e) {
98210       {
98211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98212       };
98213     } catch (std::exception& e) {
98214       {
98215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98216       };
98217     } catch (Dali::DaliException e) {
98218       {
98219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98220       };
98221     } catch (...) {
98222       {
98223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98224       };
98225     }
98226   }
98227
98228   jresult = (void *)result;
98229   return jresult;
98230 }
98231
98232
98233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98234   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98235
98236   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98237   {
98238     try {
98239       (arg1)->Reset();
98240     } catch (std::out_of_range& e) {
98241       {
98242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98243       };
98244     } catch (std::exception& e) {
98245       {
98246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98247       };
98248     } catch (Dali::DaliException e) {
98249       {
98250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98251       };
98252     } catch (...) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98255       };
98256     }
98257   }
98258
98259 }
98260
98261
98262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98263   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98264   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98265
98266   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98267   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98268   {
98269     try {
98270       (arg1)->Reset(arg2);
98271     } catch (std::out_of_range& e) {
98272       {
98273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98274       };
98275     } catch (std::exception& e) {
98276       {
98277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98278       };
98279     } catch (Dali::DaliException e) {
98280       {
98281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98282       };
98283     } catch (...) {
98284       {
98285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98286       };
98287     }
98288   }
98289
98290 }
98291
98292
98293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98294   void * jresult ;
98295   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98296   Dali::Toolkit::Ruler *result = 0 ;
98297
98298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98299   {
98300     try {
98301       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98302     } catch (std::out_of_range& e) {
98303       {
98304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98305       };
98306     } catch (std::exception& e) {
98307       {
98308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98309       };
98310     } catch (Dali::DaliException e) {
98311       {
98312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98313       };
98314     } catch (...) {
98315       {
98316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98317       };
98318     }
98319   }
98320
98321   jresult = (void *)result;
98322   return jresult;
98323 }
98324
98325
98326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98327   float jresult ;
98328   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98329   float arg2 ;
98330   float arg3 ;
98331   float result;
98332
98333   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98334   arg2 = (float)jarg2;
98335   arg3 = (float)jarg3;
98336   {
98337     try {
98338       result = (float)(*arg1)->Snap(arg2,arg3);
98339     } catch (std::out_of_range& e) {
98340       {
98341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98342       };
98343     } catch (std::exception& e) {
98344       {
98345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98346       };
98347     } catch (Dali::DaliException e) {
98348       {
98349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98350       };
98351     } catch (...) {
98352       {
98353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98354       };
98355     }
98356   }
98357
98358   jresult = result;
98359   return jresult;
98360 }
98361
98362
98363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98364   float jresult ;
98365   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98366   float arg2 ;
98367   float result;
98368
98369   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98370   arg2 = (float)jarg2;
98371   {
98372     try {
98373       result = (float)(*arg1)->Snap(arg2);
98374     } catch (std::out_of_range& e) {
98375       {
98376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98377       };
98378     } catch (std::exception& e) {
98379       {
98380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98381       };
98382     } catch (Dali::DaliException e) {
98383       {
98384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98385       };
98386     } catch (...) {
98387       {
98388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98389       };
98390     }
98391   }
98392
98393   jresult = result;
98394   return jresult;
98395 }
98396
98397
98398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98399   float jresult ;
98400   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98401   unsigned int arg2 ;
98402   unsigned int *arg3 = 0 ;
98403   bool arg4 ;
98404   float result;
98405
98406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98407   arg2 = (unsigned int)jarg2;
98408   arg3 = (unsigned int *)jarg3;
98409   arg4 = jarg4 ? true : false;
98410   {
98411     try {
98412       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98413     } catch (std::out_of_range& e) {
98414       {
98415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98416       };
98417     } catch (std::exception& e) {
98418       {
98419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98420       };
98421     } catch (Dali::DaliException e) {
98422       {
98423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98424       };
98425     } catch (...) {
98426       {
98427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98428       };
98429     }
98430   }
98431
98432   jresult = result;
98433   return jresult;
98434 }
98435
98436
98437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98438   unsigned int jresult ;
98439   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98440   float arg2 ;
98441   bool arg3 ;
98442   unsigned int result;
98443
98444   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98445   arg2 = (float)jarg2;
98446   arg3 = jarg3 ? true : false;
98447   {
98448     try {
98449       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98450     } catch (std::out_of_range& e) {
98451       {
98452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98453       };
98454     } catch (std::exception& e) {
98455       {
98456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98457       };
98458     } catch (Dali::DaliException e) {
98459       {
98460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98461       };
98462     } catch (...) {
98463       {
98464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98465       };
98466     }
98467   }
98468
98469   jresult = result;
98470   return jresult;
98471 }
98472
98473
98474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98475   unsigned int jresult ;
98476   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98477   unsigned int result;
98478
98479   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98480   {
98481     try {
98482       result = (unsigned int)(*arg1)->GetTotalPages();
98483     } catch (std::out_of_range& e) {
98484       {
98485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98486       };
98487     } catch (std::exception& e) {
98488       {
98489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98490       };
98491     } catch (Dali::DaliException e) {
98492       {
98493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98494       };
98495     } catch (...) {
98496       {
98497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98498       };
98499     }
98500   }
98501
98502   jresult = result;
98503   return jresult;
98504 }
98505
98506
98507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98508   int jresult ;
98509   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98510   Dali::Toolkit::Ruler::RulerType result;
98511
98512   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98513   {
98514     try {
98515       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98516     } catch (std::out_of_range& e) {
98517       {
98518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98519       };
98520     } catch (std::exception& e) {
98521       {
98522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98523       };
98524     } catch (Dali::DaliException e) {
98525       {
98526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98527       };
98528     } catch (...) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98531       };
98532     }
98533   }
98534
98535   jresult = (int)result;
98536   return jresult;
98537 }
98538
98539
98540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98541   unsigned int jresult ;
98542   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98543   bool result;
98544
98545   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98546   {
98547     try {
98548       result = (bool)(*arg1)->IsEnabled();
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98564       };
98565     }
98566   }
98567
98568   jresult = result;
98569   return jresult;
98570 }
98571
98572
98573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98574   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98575
98576   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98577   {
98578     try {
98579       (*arg1)->Enable();
98580     } catch (std::out_of_range& e) {
98581       {
98582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98583       };
98584     } catch (std::exception& e) {
98585       {
98586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98587       };
98588     } catch (Dali::DaliException e) {
98589       {
98590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98591       };
98592     } catch (...) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98595       };
98596     }
98597   }
98598
98599 }
98600
98601
98602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98603   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98604
98605   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98606   {
98607     try {
98608       (*arg1)->Disable();
98609     } catch (std::out_of_range& e) {
98610       {
98611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98612       };
98613     } catch (std::exception& e) {
98614       {
98615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98616       };
98617     } catch (Dali::DaliException e) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98620       };
98621     } catch (...) {
98622       {
98623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98624       };
98625     }
98626   }
98627
98628 }
98629
98630
98631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98632   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98633   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98634   Dali::Toolkit::RulerDomain *argp2 ;
98635
98636   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98637   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98638   if (!argp2) {
98639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98640     return ;
98641   }
98642   arg2 = *argp2;
98643   {
98644     try {
98645       (*arg1)->SetDomain(arg2);
98646     } catch (std::out_of_range& e) {
98647       {
98648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98649       };
98650     } catch (std::exception& e) {
98651       {
98652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98653       };
98654     } catch (Dali::DaliException e) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98657       };
98658     } catch (...) {
98659       {
98660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98661       };
98662     }
98663   }
98664
98665 }
98666
98667
98668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98669   void * jresult ;
98670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98671   Dali::Toolkit::RulerDomain *result = 0 ;
98672
98673   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98674   {
98675     try {
98676       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98677     } catch (std::out_of_range& e) {
98678       {
98679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98680       };
98681     } catch (std::exception& e) {
98682       {
98683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98684       };
98685     } catch (Dali::DaliException e) {
98686       {
98687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98688       };
98689     } catch (...) {
98690       {
98691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98692       };
98693     }
98694   }
98695
98696   jresult = (void *)result;
98697   return jresult;
98698 }
98699
98700
98701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98703
98704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98705   {
98706     try {
98707       (*arg1)->DisableDomain();
98708     } catch (std::out_of_range& e) {
98709       {
98710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98711       };
98712     } catch (std::exception& e) {
98713       {
98714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98715       };
98716     } catch (Dali::DaliException e) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98719       };
98720     } catch (...) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98723       };
98724     }
98725   }
98726
98727 }
98728
98729
98730 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98731   float jresult ;
98732   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98733   float arg2 ;
98734   float arg3 ;
98735   float arg4 ;
98736   float result;
98737
98738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98739   arg2 = (float)jarg2;
98740   arg3 = (float)jarg3;
98741   arg4 = (float)jarg4;
98742   {
98743     try {
98744       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98745     } catch (std::out_of_range& e) {
98746       {
98747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98748       };
98749     } catch (std::exception& e) {
98750       {
98751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98752       };
98753     } catch (Dali::DaliException e) {
98754       {
98755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98756       };
98757     } catch (...) {
98758       {
98759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98760       };
98761     }
98762   }
98763
98764   jresult = result;
98765   return jresult;
98766 }
98767
98768
98769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98770   float jresult ;
98771   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98772   float arg2 ;
98773   float arg3 ;
98774   float result;
98775
98776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98777   arg2 = (float)jarg2;
98778   arg3 = (float)jarg3;
98779   {
98780     try {
98781       result = (float)(*arg1)->Clamp(arg2,arg3);
98782     } catch (std::out_of_range& e) {
98783       {
98784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98785       };
98786     } catch (std::exception& e) {
98787       {
98788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98789       };
98790     } catch (Dali::DaliException e) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98793       };
98794     } catch (...) {
98795       {
98796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98797       };
98798     }
98799   }
98800
98801   jresult = result;
98802   return jresult;
98803 }
98804
98805
98806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98807   float jresult ;
98808   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98809   float arg2 ;
98810   float result;
98811
98812   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98813   arg2 = (float)jarg2;
98814   {
98815     try {
98816       result = (float)(*arg1)->Clamp(arg2);
98817     } catch (std::out_of_range& e) {
98818       {
98819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98820       };
98821     } catch (std::exception& e) {
98822       {
98823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98824       };
98825     } catch (Dali::DaliException e) {
98826       {
98827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98828       };
98829     } catch (...) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98832       };
98833     }
98834   }
98835
98836   jresult = result;
98837   return jresult;
98838 }
98839
98840
98841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98842   float jresult ;
98843   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98844   float arg2 ;
98845   float arg3 ;
98846   float arg4 ;
98847   Dali::Toolkit::ClampState *arg5 = 0 ;
98848   float result;
98849
98850   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98851   arg2 = (float)jarg2;
98852   arg3 = (float)jarg3;
98853   arg4 = (float)jarg4;
98854   arg5 = (Dali::Toolkit::ClampState *)jarg5;
98855   if (!arg5) {
98856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98857     return 0;
98858   }
98859   {
98860     try {
98861       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
98862     } catch (std::out_of_range& e) {
98863       {
98864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98865       };
98866     } catch (std::exception& e) {
98867       {
98868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98869       };
98870     } catch (Dali::DaliException e) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98873       };
98874     } catch (...) {
98875       {
98876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98877       };
98878     }
98879   }
98880
98881   jresult = result;
98882   return jresult;
98883 }
98884
98885
98886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
98887   float jresult ;
98888   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98889   float arg2 ;
98890   float arg3 ;
98891   float arg4 ;
98892   float arg5 ;
98893   float result;
98894
98895   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98896   arg2 = (float)jarg2;
98897   arg3 = (float)jarg3;
98898   arg4 = (float)jarg4;
98899   arg5 = (float)jarg5;
98900   {
98901     try {
98902       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
98903     } catch (std::out_of_range& e) {
98904       {
98905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98906       };
98907     } catch (std::exception& e) {
98908       {
98909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98910       };
98911     } catch (Dali::DaliException e) {
98912       {
98913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98914       };
98915     } catch (...) {
98916       {
98917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98918       };
98919     }
98920   }
98921
98922   jresult = result;
98923   return jresult;
98924 }
98925
98926
98927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
98928   float jresult ;
98929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98930   float arg2 ;
98931   float arg3 ;
98932   float arg4 ;
98933   float result;
98934
98935   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98936   arg2 = (float)jarg2;
98937   arg3 = (float)jarg3;
98938   arg4 = (float)jarg4;
98939   {
98940     try {
98941       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
98942     } catch (std::out_of_range& e) {
98943       {
98944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98945       };
98946     } catch (std::exception& e) {
98947       {
98948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98949       };
98950     } catch (Dali::DaliException e) {
98951       {
98952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98953       };
98954     } catch (...) {
98955       {
98956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98957       };
98958     }
98959   }
98960
98961   jresult = result;
98962   return jresult;
98963 }
98964
98965
98966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
98967   float jresult ;
98968   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98969   float arg2 ;
98970   float arg3 ;
98971   float result;
98972
98973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98974   arg2 = (float)jarg2;
98975   arg3 = (float)jarg3;
98976   {
98977     try {
98978       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
98979     } catch (std::out_of_range& e) {
98980       {
98981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98982       };
98983     } catch (std::exception& e) {
98984       {
98985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98986       };
98987     } catch (Dali::DaliException e) {
98988       {
98989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98990       };
98991     } catch (...) {
98992       {
98993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98994       };
98995     }
98996   }
98997
98998   jresult = result;
98999   return jresult;
99000 }
99001
99002
99003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99004   float jresult ;
99005   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99006   float arg2 ;
99007   float result;
99008
99009   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99010   arg2 = (float)jarg2;
99011   {
99012     try {
99013       result = (float)(*arg1)->SnapAndClamp(arg2);
99014     } catch (std::out_of_range& e) {
99015       {
99016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99017       };
99018     } catch (std::exception& e) {
99019       {
99020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99021       };
99022     } catch (Dali::DaliException e) {
99023       {
99024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99025       };
99026     } catch (...) {
99027       {
99028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99029       };
99030     }
99031   }
99032
99033   jresult = result;
99034   return jresult;
99035 }
99036
99037
99038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99039   float jresult ;
99040   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99041   float arg2 ;
99042   float arg3 ;
99043   float arg4 ;
99044   float arg5 ;
99045   Dali::Toolkit::ClampState *arg6 = 0 ;
99046   float result;
99047
99048   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99049   arg2 = (float)jarg2;
99050   arg3 = (float)jarg3;
99051   arg4 = (float)jarg4;
99052   arg5 = (float)jarg5;
99053   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99054   if (!arg6) {
99055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99056     return 0;
99057   }
99058   {
99059     try {
99060       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99061     } catch (std::out_of_range& e) {
99062       {
99063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99064       };
99065     } catch (std::exception& e) {
99066       {
99067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99068       };
99069     } catch (Dali::DaliException e) {
99070       {
99071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99072       };
99073     } catch (...) {
99074       {
99075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99076       };
99077     }
99078   }
99079
99080   jresult = result;
99081   return jresult;
99082 }
99083
99084
99085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99087
99088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99089   {
99090     try {
99091       (*arg1)->Reference();
99092     } catch (std::out_of_range& e) {
99093       {
99094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99095       };
99096     } catch (std::exception& e) {
99097       {
99098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99099       };
99100     } catch (Dali::DaliException e) {
99101       {
99102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99103       };
99104     } catch (...) {
99105       {
99106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99107       };
99108     }
99109   }
99110
99111 }
99112
99113
99114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99115   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99116
99117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99118   {
99119     try {
99120       (*arg1)->Unreference();
99121     } catch (std::out_of_range& e) {
99122       {
99123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99124       };
99125     } catch (std::exception& e) {
99126       {
99127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99128       };
99129     } catch (Dali::DaliException e) {
99130       {
99131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99132       };
99133     } catch (...) {
99134       {
99135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99136       };
99137     }
99138   }
99139
99140 }
99141
99142
99143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99144   int jresult ;
99145   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99146   int result;
99147
99148   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99149   {
99150     try {
99151       result = (int)(*arg1)->ReferenceCount();
99152     } catch (std::out_of_range& e) {
99153       {
99154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99155       };
99156     } catch (std::exception& e) {
99157       {
99158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99159       };
99160     } catch (Dali::DaliException e) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99163       };
99164     } catch (...) {
99165       {
99166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99167       };
99168     }
99169   }
99170
99171   jresult = result;
99172   return jresult;
99173 }
99174
99175
99176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99177   unsigned int jresult ;
99178   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99179   bool result;
99180
99181   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99182   {
99183     try {
99184       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99185     } catch (std::out_of_range& e) {
99186       {
99187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99188       };
99189     } catch (std::exception& e) {
99190       {
99191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99192       };
99193     } catch (Dali::DaliException e) {
99194       {
99195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99196       };
99197     } catch (...) {
99198       {
99199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99200       };
99201     }
99202   }
99203
99204   jresult = result;
99205   return jresult;
99206 }
99207
99208
99209 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99210   unsigned long jresult ;
99211   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99212   std::size_t result;
99213
99214   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99215   {
99216     try {
99217       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99218     } catch (std::out_of_range& e) {
99219       {
99220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99221       };
99222     } catch (std::exception& e) {
99223       {
99224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99225       };
99226     } catch (Dali::DaliException e) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99229       };
99230     } catch (...) {
99231       {
99232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99233       };
99234     }
99235   }
99236
99237   jresult = (unsigned long)result;
99238   return jresult;
99239 }
99240
99241
99242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99243   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99244   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99245
99246   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99247   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99248   {
99249     try {
99250       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99251     } catch (std::out_of_range& e) {
99252       {
99253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99254       };
99255     } catch (std::exception& e) {
99256       {
99257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99258       };
99259     } catch (Dali::DaliException e) {
99260       {
99261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99262       };
99263     } catch (...) {
99264       {
99265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99266       };
99267     }
99268   }
99269
99270 }
99271
99272
99273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99274   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99275   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99276
99277   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99278   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99279   {
99280     try {
99281       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99282     } catch (std::out_of_range& e) {
99283       {
99284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99285       };
99286     } catch (std::exception& e) {
99287       {
99288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99289       };
99290     } catch (Dali::DaliException e) {
99291       {
99292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99293       };
99294     } catch (...) {
99295       {
99296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99297       };
99298     }
99299   }
99300
99301 }
99302
99303
99304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99305   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99306   Dali::Toolkit::Control arg2 ;
99307   Dali::Toolkit::Control *argp2 ;
99308
99309   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99310   argp2 = (Dali::Toolkit::Control *)jarg2;
99311   if (!argp2) {
99312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99313     return ;
99314   }
99315   arg2 = *argp2;
99316   {
99317     try {
99318       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99319     } catch (std::out_of_range& e) {
99320       {
99321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99322       };
99323     } catch (std::exception& e) {
99324       {
99325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99326       };
99327     } catch (Dali::DaliException e) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99330       };
99331     } catch (...) {
99332       {
99333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99334       };
99335     }
99336   }
99337
99338 }
99339
99340
99341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99342   void * jresult ;
99343   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99344
99345   {
99346     try {
99347       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99348     } catch (std::out_of_range& e) {
99349       {
99350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99351       };
99352     } catch (std::exception& e) {
99353       {
99354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99355       };
99356     } catch (Dali::DaliException e) {
99357       {
99358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99359       };
99360     } catch (...) {
99361       {
99362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99363       };
99364     }
99365   }
99366
99367   jresult = (void *)result;
99368   return jresult;
99369 }
99370
99371
99372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99373   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99374
99375   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99376   {
99377     try {
99378       delete arg1;
99379     } catch (std::out_of_range& e) {
99380       {
99381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99382       };
99383     } catch (std::exception& e) {
99384       {
99385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99386       };
99387     } catch (Dali::DaliException e) {
99388       {
99389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99390       };
99391     } catch (...) {
99392       {
99393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99394       };
99395     }
99396   }
99397
99398 }
99399
99400 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99401   Dali::RefObject *result = NULL;
99402
99403   if (arg1)
99404   {
99405     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99406   }
99407   return result;
99408 }
99409
99410 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99411     return (Dali::RefObject *)jarg1;
99412 }
99413
99414 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99415     return (Dali::SignalObserver *)jarg1;
99416 }
99417
99418 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99419     return (Dali::ConnectionTrackerInterface *)jarg1;
99420 }
99421
99422 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99423     return (Dali::BaseHandle *)jarg1;
99424 }
99425
99426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99427     return (Dali::BaseHandle *)jarg1;
99428 }
99429
99430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99431     return (Dali::BaseHandle *)jarg1;
99432 }
99433
99434 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99435     return (Dali::BaseHandle *)jarg1;
99436 }
99437
99438 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99439     return (Dali::BaseHandle *)jarg1;
99440 }
99441
99442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99443     return (Dali::BaseHandle *)jarg1;
99444 }
99445
99446 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99447     return (Dali::BaseHandle *)jarg1;
99448 }
99449
99450 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99451     return (Dali::BaseHandle *)jarg1;
99452 }
99453
99454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99455     return (Dali::BaseHandle *)jarg1;
99456 }
99457
99458 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99459     return (Dali::BaseHandle *)jarg1;
99460 }
99461
99462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99463     return (Dali::BaseHandle *)jarg1;
99464 }
99465
99466 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99467     return (Dali::BaseHandle *)jarg1;
99468 }
99469
99470 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99471     return (Dali::BaseHandle *)jarg1;
99472 }
99473
99474 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99475     return (Dali::Handle *)jarg1;
99476 }
99477
99478 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99479     return (Dali::Handle *)jarg1;
99480 }
99481
99482 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99483     return (Dali::BaseHandle *)jarg1;
99484 }
99485
99486 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99487     return (Dali::BaseHandle *)jarg1;
99488 }
99489
99490 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99491     return (Dali::Handle *)jarg1;
99492 }
99493
99494 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99495     return (Dali::BaseHandle *)jarg1;
99496 }
99497
99498 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99499     return (Dali::Handle *)jarg1;
99500 }
99501
99502 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99503     return (Dali::GestureDetector *)jarg1;
99504 }
99505
99506 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99507     return (Dali::Gesture *)jarg1;
99508 }
99509
99510 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99511     return (Dali::Handle *)jarg1;
99512 }
99513
99514 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99515     return (Dali::Actor *)jarg1;
99516 }
99517
99518 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99519     return (Dali::BaseHandle *)jarg1;
99520 }
99521
99522 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99523     return (Dali::RefObject *)jarg1;
99524 }
99525
99526 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99527     return (Dali::Actor *)jarg1;
99528 }
99529
99530 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99531     return (Dali::GestureDetector *)jarg1;
99532 }
99533
99534 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99535     return (Dali::Gesture *)jarg1;
99536 }
99537
99538 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99539     return (Dali::GestureDetector *)jarg1;
99540 }
99541
99542 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99543     return (Dali::Gesture *)jarg1;
99544 }
99545
99546 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99547     return (Dali::GestureDetector *)jarg1;
99548 }
99549
99550 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99551     return (Dali::Gesture *)jarg1;
99552 }
99553
99554 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99555     return (Dali::BaseHandle *)jarg1;
99556 }
99557
99558 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99559     return (Dali::Handle *)jarg1;
99560 }
99561
99562 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99563     return (Dali::Handle *)jarg1;
99564 }
99565
99566 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99567     return (Dali::Handle *)jarg1;
99568 }
99569
99570 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99571     return (Dali::Image *)jarg1;
99572 }
99573
99574 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99575     return (Dali::Image *)jarg1;
99576 }
99577
99578 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99579     return (Dali::Image *)jarg1;
99580 }
99581
99582 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99583     return (Dali::RefObject *)jarg1;
99584 }
99585
99586 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99587     return (Dali::Image *)jarg1;
99588 }
99589
99590 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99591     return (Dali::Image *)jarg1;
99592 }
99593
99594 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99595     return (Dali::ResourceImage *)jarg1;
99596 }
99597
99598 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99599     return (Dali::Actor *)jarg1;
99600 }
99601
99602 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99603     return (Dali::BaseHandle *)jarg1;
99604 }
99605
99606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99607     return (Dali::BaseHandle *)jarg1;
99608 }
99609
99610 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99611     return (Dali::BaseHandle *)jarg1;
99612 }
99613
99614 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99615     return (Dali::CustomActorImpl *)jarg1;
99616 }
99617
99618 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99619     return (Dali::CustomActor *)jarg1;
99620 }
99621
99622 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99623     return (Dali::BaseHandle *)jarg1;
99624 }
99625
99626 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99627     return (Dali::Toolkit::Control *)jarg1;
99628 }
99629
99630 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99631     return (Dali::Toolkit::Control *)jarg1;
99632 }
99633
99634 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99635     return (Dali::Toolkit::Button *)jarg1;
99636 }
99637
99638 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99639     return (Dali::Toolkit::Button *)jarg1;
99640 }
99641
99642 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99643     return (Dali::Toolkit::Button *)jarg1;
99644 }
99645
99646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99647     return (Dali::Toolkit::Control *)jarg1;
99648 }
99649
99650 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99651     return (Dali::Toolkit::Control *)jarg1;
99652 }
99653
99654 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99655     return (Dali::Toolkit::Control *)jarg1;
99656 }
99657
99658 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99659     return (Dali::Toolkit::Control *)jarg1;
99660 }
99661
99662 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99663     return (Dali::Toolkit::Control *)jarg1;
99664 }
99665
99666 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99667     return (Dali::RefObject *)jarg1;
99668 }
99669
99670 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99671     return (Dali::Toolkit::Scrollable *)jarg1;
99672 }
99673
99674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99675     return (Dali::BaseHandle *)jarg1;
99676 }
99677
99678 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99679     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99680 }
99681
99682 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99683     return (Dali::RefObject *)jarg1;
99684 }
99685
99686 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99687     return (Dali::Toolkit::Ruler *)jarg1;
99688 }
99689
99690 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99691     return (Dali::Toolkit::Ruler *)jarg1;
99692 }
99693
99694 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99695     return (Dali::Toolkit::Scrollable *)jarg1;
99696 }
99697
99698 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99699     return (Dali::Toolkit::Control *)jarg1;
99700 }
99701
99702
99703 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99704     return (Dali::Toolkit::Control *)jarg1;
99705 }
99706
99707 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99708     return (Dali::BaseHandle *)jarg1;
99709 }
99710
99711 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99712     return (Dali::BaseHandle *)jarg1;
99713 }
99714
99715 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99716     return (Dali::Toolkit::Control *)jarg1;
99717 }
99718
99719 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99720     return (Dali::Toolkit::Control *)jarg1;
99721 }
99722
99723 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99724     return (Dali::Toolkit::Control *)jarg1;
99725 }
99726
99727 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99728     return (Dali::Toolkit::Control *)jarg1;
99729 }
99730
99731 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99732     return (Dali::Toolkit::Control *)jarg1;
99733 }
99734
99735 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99736     return (Dali::Toolkit::Control *)jarg1;
99737 }
99738
99739 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99740     return (Dali::Toolkit::PageTurnView *)jarg1;
99741 }
99742
99743 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99744     return (Dali::Toolkit::PageTurnView *)jarg1;
99745 }
99746
99747 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99748     return (Dali::Toolkit::Button *)jarg1;
99749 }
99750
99751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99752     return (Dali::BaseHandle *)jarg1;
99753 }
99754
99755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99756     return (Dali::BaseHandle *)jarg1;
99757 }
99758
99759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99760     return (Dali::BaseHandle *)jarg1;
99761 }
99762
99763 /*
99764  * Widget binding
99765  */
99766 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99767     return (Dali::BaseHandle *)jarg1;
99768 }
99769
99770 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99771     return (Dali::BaseObject *)jarg1;
99772 }
99773
99774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99775   void * jresult ;
99776   Dali::Widget result;
99777
99778   {
99779     try {
99780       result = Dali::Widget::New();
99781     } catch (std::out_of_range& e) {
99782       {
99783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99784       };
99785     } catch (std::exception& e) {
99786       {
99787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99788       };
99789     } catch (...) {
99790       {
99791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99792       };
99793     }
99794   }
99795   jresult = new Dali::Widget((const Dali::Widget &)result);
99796   return jresult;
99797 }
99798
99799
99800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99801   void * jresult ;
99802   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99803   Dali::Widget result;
99804
99805   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99806
99807   if (!arg1) {
99808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99809     return 0;
99810   }
99811   {
99812     try {
99813       jresult = new Dali::Widget(arg1);
99814     } catch (std::out_of_range& e) {
99815       {
99816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99817       };
99818     } catch (std::exception& e) {
99819       {
99820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99821       };
99822     } catch (...) {
99823       {
99824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99825       };
99826     }
99827   }
99828   return jresult;
99829 }
99830
99831
99832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99833   void * jresult ;
99834   Dali::Widget *result = 0 ;
99835
99836   {
99837     try {
99838       result = (Dali::Widget *)new Dali::Widget();
99839     } catch (std::out_of_range& e) {
99840       {
99841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (std::exception& e) {
99844       {
99845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99846       };
99847     } catch (...) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99850       };
99851     }
99852   }
99853   jresult = (void *)result;
99854   return jresult;
99855 }
99856
99857
99858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
99859   void * jresult ;
99860   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99861   Dali::Widget *arg2 = 0 ;
99862   Dali::Widget *result = 0 ;
99863
99864   arg1 = (Dali::Widget *)jarg1;
99865   arg2 = (Dali::Widget *)jarg2;
99866   if (!arg2) {
99867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
99868     return 0;
99869   }
99870   {
99871     try {
99872       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
99873     } catch (std::out_of_range& e) {
99874       {
99875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99876       };
99877     } catch (std::exception& e) {
99878       {
99879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99880       };
99881     } catch (...) {
99882       {
99883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99884       };
99885     }
99886   }
99887   jresult = (void *)result;
99888   return jresult;
99889 }
99890
99891
99892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
99893   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99894
99895   arg1 = (Dali::Widget *)jarg1;
99896   {
99897     try {
99898       delete arg1;
99899     } catch (std::out_of_range& e) {
99900       {
99901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99902       };
99903     } catch (std::exception& e) {
99904       {
99905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99906       };
99907     } catch (...) {
99908       {
99909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99910       };
99911     }
99912   }
99913 }
99914
99915
99916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
99917   void * jresult ;
99918   SwigDirector_WidgetImpl* result;
99919   {
99920     try {
99921       result = new SwigDirector_WidgetImpl();
99922     } catch (std::out_of_range& e) {
99923       {
99924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99925       };
99926     } catch (std::exception& e) {
99927       {
99928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99929       };
99930     } catch (...) {
99931       {
99932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99933       };
99934     }
99935   }
99936   jresult = result;
99937   return jresult;
99938 }
99939
99940
99941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
99942   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99943   std::string *arg2 = 0 ;
99944   Dali::Window arg3 ;
99945   Dali::Window *argp3 ;
99946
99947   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99948   if (!jarg2) {
99949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99950     return ;
99951   }
99952   std::string arg2_str(jarg2);
99953   arg2 = &arg2_str;
99954   argp3 = (Dali::Window *)jarg3;
99955   if (!argp3) {
99956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99957     return ;
99958   }
99959   arg3 = *argp3;
99960   {
99961     try {
99962       (arg1)->OnCreate((std::string const &)*arg2,arg3);
99963     } catch (std::out_of_range& e) {
99964       {
99965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99966       };
99967     } catch (std::exception& e) {
99968       {
99969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99970       };
99971     } catch (...) {
99972       {
99973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99974       };
99975     }
99976   }
99977 }
99978
99979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
99980   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99981   std::string *arg2 = 0 ;
99982   Dali::Window arg3 ;
99983   Dali::Window *argp3 ;
99984
99985   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99986   if (!jarg2) {
99987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99988     return ;
99989   }
99990   std::string arg2_str(jarg2);
99991   arg2 = &arg2_str;
99992   argp3 = (Dali::Window *)jarg3;
99993   if (!argp3) {
99994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99995     return ;
99996   }
99997   arg3 = *argp3;
99998   {
99999     try {
100000       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100001     } catch (std::out_of_range& e) {
100002       {
100003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100004       };
100005     } catch (std::exception& e) {
100006       {
100007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100008       };
100009     } catch (...) {
100010       {
100011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100012       };
100013     }
100014   }
100015 }
100016
100017
100018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100019   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100020   std::string *arg2 = 0 ;
100021   Dali::Widget::Termination arg3 ;
100022
100023   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100024   if (!jarg2) {
100025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100026     return ;
100027   }
100028   std::string arg2_str(jarg2);
100029   arg2 = &arg2_str;
100030   arg3 = (Dali::Widget::Termination)jarg3;
100031   {
100032     try {
100033       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100034     } catch (std::out_of_range& e) {
100035       {
100036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100037       };
100038     } catch (std::exception& e) {
100039       {
100040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100041       };
100042     } catch (...) {
100043       {
100044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100045       };
100046     }
100047   }
100048 }
100049
100050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100051   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100052   std::string *arg2 = 0 ;
100053   Dali::Widget::Termination arg3 ;
100054
100055   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100056   if (!jarg2) {
100057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100058     return ;
100059   }
100060   std::string arg2_str(jarg2);
100061   arg2 = &arg2_str;
100062   arg3 = (Dali::Widget::Termination)jarg3;
100063   {
100064     try {
100065       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100066     } catch (std::out_of_range& e) {
100067       {
100068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100069       };
100070     } catch (std::exception& e) {
100071       {
100072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100073       };
100074     } catch (...) {
100075       {
100076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100077       };
100078     }
100079   }
100080 }
100081
100082
100083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100084   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100085
100086   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100087   {
100088     try {
100089       (arg1)->OnPause();
100090     } catch (std::out_of_range& e) {
100091       {
100092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100093       };
100094     } catch (std::exception& e) {
100095       {
100096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100097       };
100098     } catch (...) {
100099       {
100100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100101       };
100102     }
100103   }
100104 }
100105
100106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100107   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100108
100109   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100110   {
100111     try {
100112       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100113     } catch (std::out_of_range& e) {
100114       {
100115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100116       };
100117     } catch (std::exception& e) {
100118       {
100119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100120       };
100121     } catch (...) {
100122       {
100123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100124       };
100125     }
100126   }
100127 }
100128
100129
100130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100131   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100132
100133   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100134   {
100135     try {
100136       (arg1)->OnResume();
100137     } catch (std::out_of_range& e) {
100138       {
100139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100140       };
100141     } catch (std::exception& e) {
100142       {
100143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100144       };
100145     } catch (...) {
100146       {
100147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100148       };
100149     }
100150   }
100151 }
100152
100153
100154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100155   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100156
100157   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100158   {
100159     try {
100160       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100161     } catch (std::out_of_range& e) {
100162       {
100163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100164       };
100165     } catch (std::exception& e) {
100166       {
100167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100168       };
100169     } catch (...) {
100170       {
100171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100172       };
100173     }
100174   }
100175 }
100176
100177
100178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100179   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100180   Dali::Window arg2 ;
100181   Dali::Window *argp2 ;
100182
100183   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100184   argp2 = (Dali::Window *)jarg2;
100185   if (!argp2) {
100186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100187     return ;
100188   }
100189   arg2 = *argp2;
100190   {
100191     try {
100192       (arg1)->OnResize(arg2);
100193     } catch (std::out_of_range& e) {
100194       {
100195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100196       };
100197     } catch (std::exception& e) {
100198       {
100199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100200       };
100201     } catch (...) {
100202       {
100203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100204       };
100205     }
100206   }
100207 }
100208
100209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100210   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100211   Dali::Window arg2 ;
100212   Dali::Window *argp2 ;
100213
100214   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100215   argp2 = (Dali::Window *)jarg2;
100216   if (!argp2) {
100217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100218     return ;
100219   }
100220   arg2 = *argp2;
100221   {
100222     try {
100223       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100224     } catch (std::out_of_range& e) {
100225       {
100226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100227       };
100228     } catch (std::exception& e) {
100229       {
100230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100231       };
100232     } catch (...) {
100233       {
100234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100235       };
100236     }
100237   }
100238 }
100239
100240
100241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100242   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100243   std::string *arg2 = 0 ;
100244   int arg3 ;
100245
100246   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100247   if (!jarg2) {
100248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100249     return ;
100250   }
100251   std::string arg2_str(jarg2);
100252   arg2 = &arg2_str;
100253   arg3 = (int)jarg3;
100254   {
100255     try {
100256       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100257     } catch (std::out_of_range& e) {
100258       {
100259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100260       };
100261     } catch (std::exception& e) {
100262       {
100263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100264       };
100265     } catch (...) {
100266       {
100267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100268       };
100269     }
100270   }
100271 }
100272
100273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100274   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100275   std::string *arg2 = 0 ;
100276   int arg3 ;
100277
100278   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100279   if (!jarg2) {
100280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100281     return ;
100282   }
100283   std::string arg2_str(jarg2);
100284   arg2 = &arg2_str;
100285   arg3 = (int)jarg3;
100286   {
100287     try {
100288       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100289     } catch (std::out_of_range& e) {
100290       {
100291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100292       };
100293     } catch (std::exception& e) {
100294       {
100295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100296       };
100297     } catch (...) {
100298       {
100299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100300       };
100301     }
100302   }
100303 }
100304
100305
100306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100307   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100308   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100309   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100310
100311   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100312   arg2 = (Dali::SlotObserver *)jarg2;
100313   arg3 = (Dali::CallbackBase *)jarg3;
100314   {
100315     try {
100316       (arg1)->SignalConnected(arg2,arg3);
100317     } catch (std::out_of_range& e) {
100318       {
100319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100320       };
100321     } catch (std::exception& e) {
100322       {
100323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100324       };
100325     } catch (...) {
100326       {
100327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100328       };
100329     }
100330   }
100331 }
100332
100333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100334   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100335   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100336   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100337
100338   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100339   arg2 = (Dali::SlotObserver *)jarg2;
100340   arg3 = (Dali::CallbackBase *)jarg3;
100341   {
100342     try {
100343       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100344     } catch (std::out_of_range& e) {
100345       {
100346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100347       };
100348     } catch (std::exception& e) {
100349       {
100350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100351       };
100352     } catch (...) {
100353       {
100354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100355       };
100356     }
100357   }
100358 }
100359
100360
100361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100362   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100363   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100364   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100365
100366   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100367   arg2 = (Dali::SlotObserver *)jarg2;
100368   arg3 = (Dali::CallbackBase *)jarg3;
100369   {
100370     try {
100371       (arg1)->SignalDisconnected(arg2,arg3);
100372     } catch (std::out_of_range& e) {
100373       {
100374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100375       };
100376     } catch (std::exception& e) {
100377       {
100378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100379       };
100380     } catch (...) {
100381       {
100382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100383       };
100384     }
100385   }
100386 }
100387
100388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100389   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100390   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100391   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100392
100393   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100394   arg2 = (Dali::SlotObserver *)jarg2;
100395   arg3 = (Dali::CallbackBase *)jarg3;
100396   {
100397     try {
100398       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100399     } catch (std::out_of_range& e) {
100400       {
100401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100402       };
100403     } catch (std::exception& e) {
100404       {
100405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100406       };
100407     } catch (...) {
100408       {
100409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100410       };
100411     }
100412   }
100413 }
100414
100415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100416   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100417   std::string *arg2 = 0 ;
100418
100419   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100420   if (!jarg2) {
100421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100422     return ;
100423   }
100424   std::string arg2_str(jarg2);
100425   arg2 = &arg2_str;
100426   {
100427     try {
100428       (arg1)->SetContentInfo((std::string const &)*arg2);
100429     } catch (std::out_of_range& e) {
100430       {
100431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100432       };
100433     } catch (std::exception& e) {
100434       {
100435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100436       };
100437     } catch (...) {
100438       {
100439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100440       };
100441     }
100442   }
100443 }
100444
100445
100446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100447   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100448   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100449
100450   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100451   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100452   {
100453     try {
100454       (arg1)->SetImpl(arg2);
100455     } catch (std::out_of_range& e) {
100456       {
100457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100458       };
100459     } catch (std::exception& e) {
100460       {
100461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100462       };
100463     } catch (...) {
100464       {
100465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100466       };
100467     }
100468   }
100469 }
100470
100471 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) {
100472
100473   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100474   if (director) {
100475     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100476   }
100477 }
100478
100479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100480   void * jresult ;
100481   Dali::Widget *arg1 = 0 ;
100482   SwigDirector_WidgetImpl *result = 0 ;
100483
100484   arg1 = (Dali::Widget *)jarg1;
100485   if (!arg1) {
100486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100487     return 0;
100488   }
100489   {
100490     try {
100491       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100492     } catch (std::out_of_range& e) {
100493       {
100494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100495       };
100496     } catch (std::exception& e) {
100497       {
100498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100499       };
100500     } catch (...) {
100501       {
100502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100503       };
100504     }
100505   }
100506
100507   jresult = (void *)result;
100508   return jresult;
100509 }
100510
100511
100512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100513   void * jresult ;
100514   int *arg1 = (int *) 0 ;
100515   char ***arg2 ;
100516   std::string *arg3 = 0 ;
100517   Dali::WidgetApplication result;
100518   {
100519     int index = 0;
100520     int length = 0;
100521     char *retPtr;
100522     char *nextPtr;
100523     argWidgetC = jarg1;
100524     argWidgetV = new char*[jarg1 + 1];
100525
100526     retPtr = strtok_r( jarg2, " ", &nextPtr);
100527     if( retPtr )
100528     {
100529       length = strlen(retPtr);
100530     }
100531     argWidgetV[index] = new char[length + 1];
100532     if( retPtr )
100533     {
100534       strncpy(argWidgetV[index], retPtr, length);
100535     }
100536     argWidgetV[index][length] = '\0';
100537     index++;
100538
100539     while (index < jarg1)
100540     {
100541       length = 0;
100542       retPtr = strtok_r(NULL, " ", &nextPtr);
100543       if( retPtr )
100544       {
100545         length = strlen(retPtr);
100546       }
100547       argWidgetV[index] = new char[length + 1];
100548       if( retPtr )
100549       {
100550         strncpy(argWidgetV[index], retPtr, length);
100551       }
100552       argWidgetV[index][length] = '\0';
100553       index++;
100554     }
100555
100556     argWidgetV[jarg1] = NULL;
100557     argWidgetC = jarg1;
100558
100559     arg1 = &argWidgetC;
100560     arg2 = &argWidgetV;
100561   }
100562
100563   if (!jarg3) {
100564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100565     return 0;
100566   }
100567   std::string arg3_str(jarg3);
100568   arg3 = &arg3_str;
100569   {
100570     try {
100571       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100572     } catch (std::out_of_range& e) {
100573       {
100574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100575       };
100576     } catch (std::exception& e) {
100577       {
100578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100579       };
100580     } catch (...) {
100581       {
100582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100583       };
100584     }
100585   }
100586   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100587
100588   return jresult;
100589 }
100590
100591
100592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100593   void * jresult ;
100594   Dali::WidgetApplication *result = 0 ;
100595
100596   {
100597     try {
100598       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100599     } catch (std::out_of_range& e) {
100600       {
100601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100602       };
100603     } catch (std::exception& e) {
100604       {
100605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100606       };
100607     } catch (...) {
100608       {
100609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100610       };
100611     }
100612   }
100613   jresult = (void *)result;
100614   return jresult;
100615 }
100616
100617
100618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100619   void * jresult ;
100620   Dali::WidgetApplication *arg1 = 0 ;
100621   Dali::WidgetApplication *result = 0 ;
100622
100623   arg1 = (Dali::WidgetApplication *)jarg1;
100624   if (!arg1) {
100625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100626     return 0;
100627   }
100628   {
100629     try {
100630       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100631     } catch (std::out_of_range& e) {
100632       {
100633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100634       };
100635     } catch (std::exception& e) {
100636       {
100637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100638       };
100639     } catch (...) {
100640       {
100641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100642       };
100643     }
100644   }
100645   jresult = (void *)result;
100646   return jresult;
100647 }
100648
100649
100650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100651   void * jresult ;
100652   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100653   Dali::WidgetApplication *arg2 = 0 ;
100654   Dali::WidgetApplication *result = 0 ;
100655
100656   arg1 = (Dali::WidgetApplication *)jarg1;
100657   arg2 = (Dali::WidgetApplication *)jarg2;
100658   if (!arg2) {
100659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100660     return 0;
100661   }
100662   {
100663     try {
100664       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100665     } catch (std::out_of_range& e) {
100666       {
100667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100668       };
100669     } catch (std::exception& e) {
100670       {
100671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100672       };
100673     } catch (...) {
100674       {
100675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100676       };
100677     }
100678   }
100679   jresult = (void *)result;
100680   return jresult;
100681 }
100682
100683
100684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100685   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100686
100687   arg1 = (Dali::WidgetApplication *)jarg1;
100688   {
100689     try {
100690       delete arg1;
100691       if( argWidgetV )
100692       {
100693         // free string data
100694         for( int i=0; i < argWidgetC+1; i++)
100695         {
100696           delete [] argWidgetV[i];
100697         }
100698         delete [] argWidgetV;
100699       }
100700     } catch (std::out_of_range& e) {
100701       {
100702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100703       };
100704     } catch (std::exception& e) {
100705       {
100706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100707       };
100708     } catch (...) {
100709       {
100710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100711       };
100712     }
100713   }
100714 }
100715
100716
100717 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100718 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100719
100720 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100721 {
100722   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100723   return *widget;
100724 }
100725
100726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100727   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100728   std::string *arg2 = 0 ;
100729
100730   arg1 = (Dali::WidgetApplication *)jarg1;
100731   if (!jarg2) {
100732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100733     return ;
100734   }
100735   std::string arg2_str(*jarg2);
100736   arg2 = &arg2_str;
100737
100738   if(!_CSharpCreateWidgetFunction)
100739   {
100740     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100741   }
100742
100743   {
100744     try {
100745       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100746     } catch (std::out_of_range& e) {
100747       {
100748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100749       };
100750     } catch (std::exception& e) {
100751       {
100752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100753       };
100754     } catch (...) {
100755       {
100756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100757       };
100758     }
100759   }
100760
100761   //Typemap argout in c++ file.
100762   //This will convert c++ string to c# string
100763   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100764 }
100765
100766
100767 //for PixelBuffer and ImageLoading
100768
100769 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100770     return (Dali::BaseHandle *)jarg1;
100771 }
100772
100773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100774   void * jresult ;
100775   unsigned int arg1 ;
100776   unsigned int arg2 ;
100777   Dali::Pixel::Format arg3 ;
100778   Dali::Devel::PixelBuffer result;
100779
100780   arg1 = (unsigned int)jarg1;
100781   arg2 = (unsigned int)jarg2;
100782   arg3 = (Dali::Pixel::Format)jarg3;
100783   {
100784     try {
100785       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100786     } catch (std::out_of_range& e) {
100787       {
100788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100789       };
100790     } catch (std::exception& e) {
100791       {
100792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100793       };
100794     } catch (...) {
100795       {
100796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100797       };
100798     }
100799   }
100800   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100801   return jresult;
100802 }
100803
100804
100805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100806   void * jresult ;
100807   Dali::Devel::PixelBuffer *result = 0 ;
100808
100809   {
100810     try {
100811       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100812     } catch (std::out_of_range& e) {
100813       {
100814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100815       };
100816     } catch (std::exception& e) {
100817       {
100818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100819       };
100820     } catch (...) {
100821       {
100822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100823       };
100824     }
100825   }
100826   jresult = (void *)result;
100827   return jresult;
100828 }
100829
100830
100831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100832   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100833
100834   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100835   {
100836     try {
100837       delete arg1;
100838     } catch (std::out_of_range& e) {
100839       {
100840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100841       };
100842     } catch (std::exception& e) {
100843       {
100844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100845       };
100846     } catch (...) {
100847       {
100848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100849       };
100850     }
100851   }
100852 }
100853
100854
100855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
100856   void * jresult ;
100857   Dali::Devel::PixelBuffer *arg1 = 0 ;
100858   Dali::Devel::PixelBuffer *result = 0 ;
100859
100860   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100861   if (!arg1) {
100862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100863     return 0;
100864   }
100865   {
100866     try {
100867       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
100868     } catch (std::out_of_range& e) {
100869       {
100870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100871       };
100872     } catch (std::exception& e) {
100873       {
100874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100875       };
100876     } catch (...) {
100877       {
100878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100879       };
100880     }
100881   }
100882   jresult = (void *)result;
100883   return jresult;
100884 }
100885
100886
100887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
100888   void * jresult ;
100889   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100890   Dali::Devel::PixelBuffer *arg2 = 0 ;
100891   Dali::Devel::PixelBuffer *result = 0 ;
100892
100893   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100894   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
100895   if (!arg2) {
100896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100897     return 0;
100898   }
100899   {
100900     try {
100901       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
100902     } catch (std::out_of_range& e) {
100903       {
100904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100905       };
100906     } catch (std::exception& e) {
100907       {
100908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100909       };
100910     } catch (...) {
100911       {
100912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100913       };
100914     }
100915   }
100916   jresult = (void *)result;
100917   return jresult;
100918 }
100919
100920
100921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
100922   void * jresult ;
100923   Dali::Devel::PixelBuffer *arg1 = 0 ;
100924   Dali::PixelData result;
100925
100926   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100927   if (!arg1) {
100928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
100929     return 0;
100930   }
100931   {
100932     try {
100933       result = Dali::Devel::PixelBuffer::Convert(*arg1);
100934     } catch (std::out_of_range& e) {
100935       {
100936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100937       };
100938     } catch (std::exception& e) {
100939       {
100940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100941       };
100942     } catch (...) {
100943       {
100944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100945       };
100946     }
100947   }
100948   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100949   return jresult;
100950 }
100951
100952
100953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
100954   void * jresult ;
100955   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100956   Dali::PixelData result;
100957
100958   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100959   {
100960     try {
100961       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
100962     } catch (std::out_of_range& e) {
100963       {
100964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100965       };
100966     } catch (std::exception& e) {
100967       {
100968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100969       };
100970     } catch (...) {
100971       {
100972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100973       };
100974     }
100975   }
100976   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100977   return jresult;
100978 }
100979
100980
100981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
100982   void * jresult ;
100983   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100984   unsigned char *result = 0 ;
100985
100986   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100987   {
100988     try {
100989       result = (unsigned char *)(arg1)->GetBuffer();
100990     } catch (std::out_of_range& e) {
100991       {
100992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100993       };
100994     } catch (std::exception& e) {
100995       {
100996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100997       };
100998     } catch (...) {
100999       {
101000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101001       };
101002     }
101003   }
101004   jresult = (void *)result;
101005   return jresult;
101006 }
101007
101008
101009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101010   unsigned int jresult ;
101011   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101012   unsigned int result;
101013
101014   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101015   {
101016     try {
101017       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101018     } catch (std::out_of_range& e) {
101019       {
101020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101021       };
101022     } catch (std::exception& e) {
101023       {
101024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101025       };
101026     } catch (...) {
101027       {
101028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101029       };
101030     }
101031   }
101032   jresult = result;
101033   return jresult;
101034 }
101035
101036
101037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101038   unsigned int jresult ;
101039   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101040   unsigned int result;
101041
101042   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101043   {
101044     try {
101045       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101046     } catch (std::out_of_range& e) {
101047       {
101048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101049       };
101050     } catch (std::exception& e) {
101051       {
101052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101053       };
101054     } catch (...) {
101055       {
101056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101057       };
101058     }
101059   }
101060   jresult = result;
101061   return jresult;
101062 }
101063
101064
101065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101066   int jresult ;
101067   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101068   Dali::Pixel::Format result;
101069
101070   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101071   {
101072     try {
101073       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101074     } catch (std::out_of_range& e) {
101075       {
101076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101077       };
101078     } catch (std::exception& e) {
101079       {
101080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101081       };
101082     } catch (...) {
101083       {
101084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101085       };
101086     }
101087   }
101088   jresult = (int)result;
101089   return jresult;
101090 }
101091
101092
101093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101094   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101095   Dali::Devel::PixelBuffer arg2 ;
101096   float arg3 ;
101097   bool arg4 ;
101098   Dali::Devel::PixelBuffer *argp2 ;
101099
101100   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101101   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101102   if (!argp2) {
101103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101104     return ;
101105   }
101106   arg2 = *argp2;
101107   arg3 = (float)jarg3;
101108   arg4 = jarg4 ? true : false;
101109   {
101110     try {
101111       (arg1)->ApplyMask(arg2,arg3,arg4);
101112     } catch (std::out_of_range& e) {
101113       {
101114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101115       };
101116     } catch (std::exception& e) {
101117       {
101118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101119       };
101120     } catch (...) {
101121       {
101122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101123       };
101124     }
101125   }
101126 }
101127
101128
101129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101130   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101131   Dali::Devel::PixelBuffer arg2 ;
101132   float arg3 ;
101133   Dali::Devel::PixelBuffer *argp2 ;
101134
101135   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101136   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101137   if (!argp2) {
101138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101139     return ;
101140   }
101141   arg2 = *argp2;
101142   arg3 = (float)jarg3;
101143   {
101144     try {
101145       (arg1)->ApplyMask(arg2,arg3);
101146     } catch (std::out_of_range& e) {
101147       {
101148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101149       };
101150     } catch (std::exception& e) {
101151       {
101152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101153       };
101154     } catch (...) {
101155       {
101156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101157       };
101158     }
101159   }
101160 }
101161
101162
101163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101164   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101165   Dali::Devel::PixelBuffer arg2 ;
101166   Dali::Devel::PixelBuffer *argp2 ;
101167
101168   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101169   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101170   if (!argp2) {
101171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101172     return ;
101173   }
101174   arg2 = *argp2;
101175   {
101176     try {
101177       (arg1)->ApplyMask(arg2);
101178     } catch (std::out_of_range& e) {
101179       {
101180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101181       };
101182     } catch (std::exception& e) {
101183       {
101184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101185       };
101186     } catch (...) {
101187       {
101188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101189       };
101190     }
101191   }
101192 }
101193
101194
101195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101196   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101197   float arg2 ;
101198
101199   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101200   arg2 = (float)jarg2;
101201   {
101202     try {
101203       (arg1)->ApplyGaussianBlur(arg2);
101204     } catch (std::out_of_range& e) {
101205       {
101206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101207       };
101208     } catch (std::exception& e) {
101209       {
101210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101211       };
101212     } catch (...) {
101213       {
101214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101215       };
101216     }
101217   }
101218 }
101219
101220
101221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101222   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101223   uint16_t arg2 ;
101224   uint16_t arg3 ;
101225   uint16_t arg4 ;
101226   uint16_t arg5 ;
101227
101228   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101229   arg2 = (uint16_t)jarg2;
101230   arg3 = (uint16_t)jarg3;
101231   arg4 = (uint16_t)jarg4;
101232   arg5 = (uint16_t)jarg5;
101233   {
101234     try {
101235       (arg1)->Crop(arg2,arg3,arg4,arg5);
101236     } catch (std::out_of_range& e) {
101237       {
101238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101239       };
101240     } catch (std::exception& e) {
101241       {
101242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101243       };
101244     } catch (...) {
101245       {
101246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101247       };
101248     }
101249   }
101250 }
101251
101252
101253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101254   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101255   uint16_t arg2 ;
101256   uint16_t arg3 ;
101257
101258   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101259   arg2 = (uint16_t)jarg2;
101260   arg3 = (uint16_t)jarg3;
101261   {
101262     try {
101263       (arg1)->Resize(arg2,arg3);
101264     } catch (std::out_of_range& e) {
101265       {
101266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101267       };
101268     } catch (std::exception& e) {
101269       {
101270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101271       };
101272     } catch (...) {
101273       {
101274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101275       };
101276     }
101277   }
101278 }
101279
101280
101281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101282   void * jresult ;
101283   std::string *arg1 = 0 ;
101284   Dali::ImageDimensions arg2 ;
101285   Dali::FittingMode::Type arg3 ;
101286   Dali::SamplingMode::Type arg4 ;
101287   bool arg5 ;
101288   Dali::ImageDimensions *argp2 ;
101289   Dali::Devel::PixelBuffer result;
101290
101291   if (!jarg1) {
101292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101293     return 0;
101294   }
101295   std::string arg1_str(jarg1);
101296   arg1 = &arg1_str;
101297   argp2 = (Dali::ImageDimensions *)jarg2;
101298   if (!argp2) {
101299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101300     return 0;
101301   }
101302   arg2 = *argp2;
101303   arg3 = (Dali::FittingMode::Type)jarg3;
101304   arg4 = (Dali::SamplingMode::Type)jarg4;
101305   arg5 = jarg5 ? true : false;
101306   {
101307     try {
101308       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101309     } catch (std::out_of_range& e) {
101310       {
101311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101312       };
101313     } catch (std::exception& e) {
101314       {
101315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101316       };
101317     } catch (...) {
101318       {
101319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101320       };
101321     }
101322   }
101323   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101324
101325   return jresult;
101326 }
101327
101328
101329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101330   void * jresult ;
101331   std::string *arg1 = 0 ;
101332   Dali::ImageDimensions arg2 ;
101333   Dali::FittingMode::Type arg3 ;
101334   Dali::SamplingMode::Type arg4 ;
101335   Dali::ImageDimensions *argp2 ;
101336   Dali::Devel::PixelBuffer result;
101337
101338   if (!jarg1) {
101339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101340     return 0;
101341   }
101342   std::string arg1_str(jarg1);
101343   arg1 = &arg1_str;
101344   argp2 = (Dali::ImageDimensions *)jarg2;
101345   if (!argp2) {
101346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101347     return 0;
101348   }
101349   arg2 = *argp2;
101350   arg3 = (Dali::FittingMode::Type)jarg3;
101351   arg4 = (Dali::SamplingMode::Type)jarg4;
101352   {
101353     try {
101354       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101355     } catch (std::out_of_range& e) {
101356       {
101357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101358       };
101359     } catch (std::exception& e) {
101360       {
101361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101362       };
101363     } catch (...) {
101364       {
101365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101366       };
101367     }
101368   }
101369   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101370
101371   return jresult;
101372 }
101373
101374
101375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101376   void * jresult ;
101377   std::string *arg1 = 0 ;
101378   Dali::ImageDimensions arg2 ;
101379   Dali::FittingMode::Type arg3 ;
101380   Dali::ImageDimensions *argp2 ;
101381   Dali::Devel::PixelBuffer result;
101382
101383   if (!jarg1) {
101384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101385     return 0;
101386   }
101387   std::string arg1_str(jarg1);
101388   arg1 = &arg1_str;
101389   argp2 = (Dali::ImageDimensions *)jarg2;
101390   if (!argp2) {
101391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101392     return 0;
101393   }
101394   arg2 = *argp2;
101395   arg3 = (Dali::FittingMode::Type)jarg3;
101396   {
101397     try {
101398       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101399     } catch (std::out_of_range& e) {
101400       {
101401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101402       };
101403     } catch (std::exception& e) {
101404       {
101405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101406       };
101407     } catch (...) {
101408       {
101409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101410       };
101411     }
101412   }
101413   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101414
101415   return jresult;
101416 }
101417
101418
101419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101420   void * jresult ;
101421   std::string *arg1 = 0 ;
101422   Dali::ImageDimensions arg2 ;
101423   Dali::ImageDimensions *argp2 ;
101424   Dali::Devel::PixelBuffer result;
101425
101426   if (!jarg1) {
101427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101428     return 0;
101429   }
101430   std::string arg1_str(jarg1);
101431   arg1 = &arg1_str;
101432   argp2 = (Dali::ImageDimensions *)jarg2;
101433   if (!argp2) {
101434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101435     return 0;
101436   }
101437   arg2 = *argp2;
101438   {
101439     try {
101440       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101441     } catch (std::out_of_range& e) {
101442       {
101443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101444       };
101445     } catch (std::exception& e) {
101446       {
101447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101448       };
101449     } catch (...) {
101450       {
101451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101452       };
101453     }
101454   }
101455   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101456
101457   return jresult;
101458 }
101459
101460
101461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101462   void * jresult ;
101463   std::string *arg1 = 0 ;
101464   Dali::Devel::PixelBuffer result;
101465
101466   if (!jarg1) {
101467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101468     return 0;
101469   }
101470   std::string arg1_str(jarg1);
101471   arg1 = &arg1_str;
101472   {
101473     try {
101474       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101475     } catch (std::out_of_range& e) {
101476       {
101477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101478       };
101479     } catch (std::exception& e) {
101480       {
101481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101482       };
101483     } catch (...) {
101484       {
101485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101486       };
101487     }
101488   }
101489   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101490
101491   return jresult;
101492 }
101493
101494
101495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101496   void * jresult ;
101497   std::string *arg1 = 0 ;
101498   Dali::ImageDimensions arg2 ;
101499   Dali::FittingMode::Type arg3 ;
101500   Dali::SamplingMode::Type arg4 ;
101501   bool arg5 ;
101502   Dali::ImageDimensions *argp2 ;
101503   Dali::ImageDimensions result;
101504
101505   if (!jarg1) {
101506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101507     return 0;
101508   }
101509   std::string arg1_str(jarg1);
101510   arg1 = &arg1_str;
101511   argp2 = (Dali::ImageDimensions *)jarg2;
101512   if (!argp2) {
101513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101514     return 0;
101515   }
101516   arg2 = *argp2;
101517   arg3 = (Dali::FittingMode::Type)jarg3;
101518   arg4 = (Dali::SamplingMode::Type)jarg4;
101519   arg5 = jarg5 ? true : false;
101520   {
101521     try {
101522       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101523     } catch (std::out_of_range& e) {
101524       {
101525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101526       };
101527     } catch (std::exception& e) {
101528       {
101529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101530       };
101531     } catch (...) {
101532       {
101533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101534       };
101535     }
101536   }
101537   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101538
101539   return jresult;
101540 }
101541
101542
101543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101544   void * jresult ;
101545   std::string *arg1 = 0 ;
101546   Dali::ImageDimensions arg2 ;
101547   Dali::FittingMode::Type arg3 ;
101548   Dali::SamplingMode::Type arg4 ;
101549   Dali::ImageDimensions *argp2 ;
101550   Dali::ImageDimensions result;
101551
101552   if (!jarg1) {
101553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101554     return 0;
101555   }
101556   std::string arg1_str(jarg1);
101557   arg1 = &arg1_str;
101558   argp2 = (Dali::ImageDimensions *)jarg2;
101559   if (!argp2) {
101560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101561     return 0;
101562   }
101563   arg2 = *argp2;
101564   arg3 = (Dali::FittingMode::Type)jarg3;
101565   arg4 = (Dali::SamplingMode::Type)jarg4;
101566   {
101567     try {
101568       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101569     } catch (std::out_of_range& e) {
101570       {
101571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101572       };
101573     } catch (std::exception& e) {
101574       {
101575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101576       };
101577     } catch (...) {
101578       {
101579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101580       };
101581     }
101582   }
101583   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101584
101585   return jresult;
101586 }
101587
101588
101589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101590   void * jresult ;
101591   std::string *arg1 = 0 ;
101592   Dali::ImageDimensions arg2 ;
101593   Dali::FittingMode::Type arg3 ;
101594   Dali::ImageDimensions *argp2 ;
101595   Dali::ImageDimensions result;
101596
101597   if (!jarg1) {
101598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101599     return 0;
101600   }
101601   std::string arg1_str(jarg1);
101602   arg1 = &arg1_str;
101603   argp2 = (Dali::ImageDimensions *)jarg2;
101604   if (!argp2) {
101605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101606     return 0;
101607   }
101608   arg2 = *argp2;
101609   arg3 = (Dali::FittingMode::Type)jarg3;
101610   {
101611     try {
101612       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101613     } catch (std::out_of_range& e) {
101614       {
101615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101616       };
101617     } catch (std::exception& e) {
101618       {
101619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101620       };
101621     } catch (...) {
101622       {
101623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101624       };
101625     }
101626   }
101627   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101628
101629   return jresult;
101630 }
101631
101632
101633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101634   void * jresult ;
101635   std::string *arg1 = 0 ;
101636   Dali::ImageDimensions arg2 ;
101637   Dali::ImageDimensions *argp2 ;
101638   Dali::ImageDimensions result;
101639
101640   if (!jarg1) {
101641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101642     return 0;
101643   }
101644   std::string arg1_str(jarg1);
101645   arg1 = &arg1_str;
101646   argp2 = (Dali::ImageDimensions *)jarg2;
101647   if (!argp2) {
101648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101649     return 0;
101650   }
101651   arg2 = *argp2;
101652   {
101653     try {
101654       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101655     } catch (std::out_of_range& e) {
101656       {
101657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101658       };
101659     } catch (std::exception& e) {
101660       {
101661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101662       };
101663     } catch (...) {
101664       {
101665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101666       };
101667     }
101668   }
101669   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101670
101671   return jresult;
101672 }
101673
101674
101675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101676   void * jresult ;
101677   std::string *arg1 = 0 ;
101678   Dali::ImageDimensions result;
101679
101680   if (!jarg1) {
101681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101682     return 0;
101683   }
101684   std::string arg1_str(jarg1);
101685   arg1 = &arg1_str;
101686   {
101687     try {
101688       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101689     } catch (std::out_of_range& e) {
101690       {
101691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101692       };
101693     } catch (std::exception& e) {
101694       {
101695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101696       };
101697     } catch (...) {
101698       {
101699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101700       };
101701     }
101702   }
101703   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101704
101705   return jresult;
101706 }
101707
101708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101709   void * jresult ;
101710   std::string *arg1 = 0 ;
101711   Dali::ImageDimensions result;
101712
101713   if (!jarg1) {
101714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101715     return 0;
101716   }
101717   std::string arg1_str(jarg1);
101718   arg1 = &arg1_str;
101719   {
101720     try {
101721       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101722     } catch (std::out_of_range& e) {
101723       {
101724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (std::exception& e) {
101727       {
101728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101729       };
101730     } catch (...) {
101731       {
101732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101733       };
101734     }
101735   }
101736   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101737
101738   return jresult;
101739 }
101740
101741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101742   void * jresult ;
101743   std::string *arg1 = 0 ;
101744   Dali::ImageDimensions arg2 ;
101745   Dali::FittingMode::Type arg3 ;
101746   Dali::SamplingMode::Type arg4 ;
101747   bool arg5 ;
101748   Dali::ImageDimensions *argp2 ;
101749   Dali::Devel::PixelBuffer result;
101750
101751   if (!jarg1) {
101752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101753     return 0;
101754   }
101755   std::string arg1_str(jarg1);
101756   arg1 = &arg1_str;
101757   argp2 = (Dali::ImageDimensions *)jarg2;
101758   if (!argp2) {
101759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101760     return 0;
101761   }
101762   arg2 = *argp2;
101763   arg3 = (Dali::FittingMode::Type)jarg3;
101764   arg4 = (Dali::SamplingMode::Type)jarg4;
101765   arg5 = jarg5 ? true : false;
101766   {
101767     try {
101768       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101769     } catch (std::out_of_range& e) {
101770       {
101771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101772       };
101773     } catch (std::exception& e) {
101774       {
101775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101776       };
101777     } catch (...) {
101778       {
101779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101780       };
101781     }
101782   }
101783   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101784
101785   return jresult;
101786 }
101787
101788
101789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101790   void * jresult ;
101791   std::string *arg1 = 0 ;
101792   Dali::ImageDimensions arg2 ;
101793   Dali::FittingMode::Type arg3 ;
101794   Dali::SamplingMode::Type arg4 ;
101795   Dali::ImageDimensions *argp2 ;
101796   Dali::Devel::PixelBuffer result;
101797
101798   if (!jarg1) {
101799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101800     return 0;
101801   }
101802   std::string arg1_str(jarg1);
101803   arg1 = &arg1_str;
101804   argp2 = (Dali::ImageDimensions *)jarg2;
101805   if (!argp2) {
101806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101807     return 0;
101808   }
101809   arg2 = *argp2;
101810   arg3 = (Dali::FittingMode::Type)jarg3;
101811   arg4 = (Dali::SamplingMode::Type)jarg4;
101812   {
101813     try {
101814       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101815     } catch (std::out_of_range& e) {
101816       {
101817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101818       };
101819     } catch (std::exception& e) {
101820       {
101821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101822       };
101823     } catch (...) {
101824       {
101825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101826       };
101827     }
101828   }
101829   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101830
101831   return jresult;
101832 }
101833
101834
101835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101836   void * jresult ;
101837   std::string *arg1 = 0 ;
101838   Dali::ImageDimensions arg2 ;
101839   Dali::FittingMode::Type arg3 ;
101840   Dali::ImageDimensions *argp2 ;
101841   Dali::Devel::PixelBuffer result;
101842
101843   if (!jarg1) {
101844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101845     return 0;
101846   }
101847   std::string arg1_str(jarg1);
101848   arg1 = &arg1_str;
101849   argp2 = (Dali::ImageDimensions *)jarg2;
101850   if (!argp2) {
101851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101852     return 0;
101853   }
101854   arg2 = *argp2;
101855   arg3 = (Dali::FittingMode::Type)jarg3;
101856   {
101857     try {
101858       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
101859     } catch (std::out_of_range& e) {
101860       {
101861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101862       };
101863     } catch (std::exception& e) {
101864       {
101865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101866       };
101867     } catch (...) {
101868       {
101869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101870       };
101871     }
101872   }
101873   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101874
101875   return jresult;
101876 }
101877
101878
101879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
101880   void * jresult ;
101881   std::string *arg1 = 0 ;
101882   Dali::ImageDimensions arg2 ;
101883   Dali::ImageDimensions *argp2 ;
101884   Dali::Devel::PixelBuffer result;
101885
101886   if (!jarg1) {
101887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101888     return 0;
101889   }
101890   std::string arg1_str(jarg1);
101891   arg1 = &arg1_str;
101892   argp2 = (Dali::ImageDimensions *)jarg2;
101893   if (!argp2) {
101894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101895     return 0;
101896   }
101897   arg2 = *argp2;
101898   {
101899     try {
101900       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
101901     } catch (std::out_of_range& e) {
101902       {
101903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101904       };
101905     } catch (std::exception& e) {
101906       {
101907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101908       };
101909     } catch (...) {
101910       {
101911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101912       };
101913     }
101914   }
101915   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101916
101917   return jresult;
101918 }
101919
101920
101921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
101922   void * jresult ;
101923   std::string *arg1 = 0 ;
101924   Dali::Devel::PixelBuffer result;
101925
101926   if (!jarg1) {
101927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101928     return 0;
101929   }
101930   std::string arg1_str(jarg1);
101931   arg1 = &arg1_str;
101932   {
101933     try {
101934       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
101935     } catch (std::out_of_range& e) {
101936       {
101937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101938       };
101939     } catch (std::exception& e) {
101940       {
101941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101942       };
101943     } catch (...) {
101944       {
101945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101946       };
101947     }
101948   }
101949   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101950
101951   return jresult;
101952 }
101953
101954
101955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
101956   void * jresult ;
101957   Dali::Toolkit::WebView result;
101958
101959   {
101960     try {
101961       result = Dali::Toolkit::WebView::New();
101962     } catch (std::out_of_range& e) {
101963       {
101964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101965       };
101966     } catch (std::exception& e) {
101967       {
101968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101969       };
101970     } catch (Dali::DaliException e) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101973       };
101974     } catch (...) {
101975       {
101976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101977       };
101978     }
101979   }
101980   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101981   return jresult;
101982 }
101983
101984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
101985   void * jresult ;
101986   Dali::Toolkit::WebView result;
101987
101988   std::string *arg1;
101989   std::string *arg2;
101990
101991   if (!jarg1) {
101992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
101993     return 0;
101994   }
101995   if (!jarg2) {
101996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
101997     return 0;
101998   }
101999
102000   std::string jarg1_str = std::string(jarg1);
102001   std::string jarg2_str = std::string(jarg2);
102002
102003   arg1 = &jarg1_str;
102004   arg2 = &jarg2_str;
102005
102006   {
102007     try {
102008       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102009     } catch (std::out_of_range& e) {
102010       {
102011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102012       };
102013     } catch (std::exception& e) {
102014       {
102015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102016       };
102017     } catch (Dali::DaliException e) {
102018       {
102019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102020       };
102021     } catch (...) {
102022       {
102023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102024       };
102025     }
102026   }
102027   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102028   return jresult;
102029 }
102030
102031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102032   void * jresult ;
102033   Dali::Toolkit::WebView *arg1 = 0 ;
102034   Dali::Toolkit::WebView *result = 0 ;
102035
102036   arg1 = (Dali::Toolkit::WebView *)jarg1;
102037   if (!arg1) {
102038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102039     return 0;
102040   }
102041   {
102042     try {
102043       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102044     } catch (std::out_of_range& e) {
102045       {
102046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102047       };
102048     } catch (std::exception& e) {
102049       {
102050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102051       };
102052     } catch (Dali::DaliException e) {
102053       {
102054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102055       };
102056     } catch (...) {
102057       {
102058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102059       };
102060     }
102061   }
102062   jresult = (void *)result;
102063   return jresult;
102064 }
102065
102066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102067   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102068   arg1 = (Dali::Toolkit::WebView *)jarg1;
102069   {
102070     try {
102071       delete arg1;
102072     } catch (std::out_of_range& e) {
102073       {
102074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102075       };
102076     } catch (std::exception& e) {
102077       {
102078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102079       };
102080     } catch (Dali::DaliException e) {
102081       {
102082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102083       };
102084     } catch (...) {
102085       {
102086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102087       };
102088     }
102089   }
102090 }
102091
102092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102093   void * jresult ;
102094   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102095   Dali::Toolkit::WebView *arg2 = 0 ;
102096   Dali::Toolkit::WebView *result = 0 ;
102097
102098   arg1 = (Dali::Toolkit::WebView *)jarg1;
102099   arg2 = (Dali::Toolkit::WebView *)jarg2;
102100   if (!arg2) {
102101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102102     return 0;
102103   }
102104   {
102105     try {
102106       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102107     } catch (std::out_of_range& e) {
102108       {
102109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102110       };
102111     } catch (std::exception& e) {
102112       {
102113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102114       };
102115     } catch (Dali::DaliException e) {
102116       {
102117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102118       };
102119     } catch (...) {
102120       {
102121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102122       };
102123     }
102124   }
102125   jresult = (void *)result;
102126   return jresult;
102127 }
102128
102129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102130   void * jresult ;
102131   Dali::BaseHandle arg1 ;
102132   Dali::BaseHandle *argp1 ;
102133   Dali::Toolkit::WebView result;
102134
102135   argp1 = (Dali::BaseHandle *)jarg1;
102136   if (!argp1) {
102137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102138     return 0;
102139   }
102140   arg1 = *argp1;
102141   {
102142     try {
102143       result = Dali::Toolkit::WebView::DownCast(arg1);
102144     } catch (std::out_of_range& e) {
102145       {
102146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102147       };
102148     } catch (std::exception& e) {
102149       {
102150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102151       };
102152     } catch (Dali::DaliException e) {
102153       {
102154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102155       };
102156     } catch (...) {
102157       {
102158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102159       };
102160     }
102161   }
102162   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102163   return jresult;
102164 }
102165
102166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102167   return (int) Dali::Toolkit::WebView::Property::URL;
102168 }
102169
102170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102171   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102172 }
102173
102174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102175   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102176 }
102177
102178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102179   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102180 }
102181
102182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102183   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102184 }
102185
102186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102187   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102188 }
102189
102190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102191   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102192 }
102193
102194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102195   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102196 }
102197
102198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102199   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102200   std::string *arg2;
102201
102202   arg1 = (Dali::Toolkit::WebView *)jarg1;
102203
102204   if (!jarg2) {
102205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102206     return;
102207   }
102208
102209   std::string jarg2str = std::string(jarg2);
102210   arg2 = &jarg2str;
102211   {
102212     try {
102213       (arg1)->LoadUrl((std::string const &)*arg2);
102214     } catch (std::out_of_range& e) {
102215       {
102216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102217       };
102218     } catch (std::exception& e) {
102219       {
102220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102221       };
102222     } catch (Dali::DaliException e) {
102223       {
102224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102225       };
102226     } catch (...) {
102227       {
102228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102229       };
102230     }
102231   }
102232 }
102233
102234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102235   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102236   std::string *arg2;
102237
102238   arg1 = (Dali::Toolkit::WebView *)jarg1;
102239   if (!jarg2) {
102240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102241     return;
102242   }
102243   std::string jarg2str = std::string(jarg2);
102244   arg2 = &jarg2str;
102245   {
102246     try {
102247       (arg1)->LoadHTMLString((std::string const &)*arg2);
102248     } catch (std::out_of_range& e) {
102249       {
102250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102251       };
102252     } catch (std::exception& e) {
102253       {
102254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102255       };
102256     } catch (Dali::DaliException e) {
102257       {
102258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102259       };
102260     } catch (...) {
102261       {
102262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102263       };
102264     }
102265   }
102266 }
102267
102268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102269   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102270
102271   arg1 = (Dali::Toolkit::WebView *)jarg1;
102272   {
102273     try {
102274       (arg1)->Reload();
102275     } catch (std::out_of_range& e) {
102276       {
102277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102278       };
102279     } catch (std::exception& e) {
102280       {
102281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102282       };
102283     } catch (Dali::DaliException e) {
102284       {
102285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102286       };
102287     } catch (...) {
102288       {
102289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102290       };
102291     }
102292   }
102293 }
102294
102295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102296   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102297
102298   arg1 = (Dali::Toolkit::WebView *)jarg1;
102299   {
102300     try {
102301       (arg1)->StopLoading();
102302     } catch (std::out_of_range& e) {
102303       {
102304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102305       };
102306     } catch (std::exception& e) {
102307       {
102308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102309       };
102310     } catch (Dali::DaliException e) {
102311       {
102312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102313       };
102314     } catch (...) {
102315       {
102316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102317       };
102318     }
102319   }
102320 }
102321
102322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102323   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102324
102325   arg1 = (Dali::Toolkit::WebView *)jarg1;
102326   {
102327     try {
102328       (arg1)->Suspend();
102329     } catch (std::out_of_range& e) {
102330       {
102331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102332       };
102333     } catch (std::exception& e) {
102334       {
102335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102336       };
102337     } catch (Dali::DaliException e) {
102338       {
102339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102340       };
102341     } catch (...) {
102342       {
102343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102344       };
102345     }
102346   }
102347 }
102348
102349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102350   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102351
102352   arg1 = (Dali::Toolkit::WebView *)jarg1;
102353   {
102354     try {
102355       (arg1)->Resume();
102356     } catch (std::out_of_range& e) {
102357       {
102358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102359       };
102360     } catch (std::exception& e) {
102361       {
102362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102363       };
102364     } catch (Dali::DaliException e) {
102365       {
102366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102367       };
102368     } catch (...) {
102369       {
102370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102371       };
102372     }
102373   }
102374 }
102375
102376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102377   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102378
102379   arg1 = (Dali::Toolkit::WebView *)jarg1;
102380   {
102381     try {
102382       (arg1)->GoBack();
102383     } catch (std::out_of_range& e) {
102384       {
102385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102386       };
102387     } catch (std::exception& e) {
102388       {
102389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102390       };
102391     } catch (Dali::DaliException e) {
102392       {
102393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102394       };
102395     } catch (...) {
102396       {
102397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102398       };
102399     }
102400   }
102401 }
102402
102403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102404   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102405
102406   arg1 = (Dali::Toolkit::WebView *)jarg1;
102407   {
102408     try {
102409       (arg1)->GoForward();
102410     } catch (std::out_of_range& e) {
102411       {
102412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102413       };
102414     } catch (std::exception& e) {
102415       {
102416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102417       };
102418     } catch (Dali::DaliException e) {
102419       {
102420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102421       };
102422     } catch (...) {
102423       {
102424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102425       };
102426     }
102427   }
102428 }
102429
102430 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102431   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102432   bool ret;
102433
102434   arg1 = (Dali::Toolkit::WebView *)jarg1;
102435   {
102436     try {
102437       ret = (arg1)->CanGoBack();
102438     } catch (std::out_of_range& e) {
102439       {
102440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102441       };
102442     } catch (std::exception& e) {
102443       {
102444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102445       };
102446     } catch (Dali::DaliException e) {
102447       {
102448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102449       };
102450     } catch (...) {
102451       {
102452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102453       };
102454     }
102455   }
102456   return ret;
102457 }
102458
102459 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102460   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102461   bool ret;
102462
102463   arg1 = (Dali::Toolkit::WebView *)jarg1;
102464   {
102465     try {
102466       ret = (arg1)->CanGoForward();
102467     } catch (std::out_of_range& e) {
102468       {
102469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102470       };
102471     } catch (std::exception& e) {
102472       {
102473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102474       };
102475     } catch (Dali::DaliException e) {
102476       {
102477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102478       };
102479     } catch (...) {
102480       {
102481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102482       };
102483     }
102484   }
102485   return ret;
102486 }
102487
102488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102489   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102490   std::string *arg2;
102491
102492   arg1 = (Dali::Toolkit::WebView *)jarg1;
102493   if (!jarg2) {
102494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102495     return;
102496   }
102497   std::string jarg2_str = std::string(jarg2);
102498   arg2 = &jarg2_str;
102499
102500   {
102501     try {
102502       if (jarg3) {
102503         void (*handler)(char*) = (void (*)(char*)) jarg3;
102504         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102505           handler(SWIG_csharp_string_callback(result.c_str()));
102506         });
102507       } else {
102508         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102509       }
102510     } catch (std::out_of_range& e) {
102511       {
102512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102513       };
102514     } catch (std::exception& e) {
102515       {
102516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102517       };
102518     } catch (Dali::DaliException e) {
102519       {
102520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102521       };
102522     } catch (...) {
102523       {
102524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102525       };
102526     }
102527   }
102528 }
102529
102530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102531 {
102532   if (!jarg2) {
102533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102534     return;
102535   }
102536
102537   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102538   std::string exposedObjectName = jarg2;
102539   void (*handler)(char*) = (void (*)(char*)) jarg3;
102540
102541   {
102542     try {
102543       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102544         handler(SWIG_csharp_string_callback(message.c_str()));
102545       });
102546     } catch (std::out_of_range& e) {
102547       {
102548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102549       };
102550     } catch (std::exception& e) {
102551       {
102552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102553       };
102554     } catch (Dali::DaliException e) {
102555       {
102556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102557       };
102558     } catch (...) {
102559       {
102560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102561       };
102562     }
102563   }
102564 }
102565
102566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102567   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102568
102569   arg1 = (Dali::Toolkit::WebView *)jarg1;
102570   {
102571     try {
102572       (arg1)->ClearHistory();
102573     } catch (std::out_of_range& e) {
102574       {
102575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102576       };
102577     } catch (std::exception& e) {
102578       {
102579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102580       };
102581     } catch (Dali::DaliException e) {
102582       {
102583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102584       };
102585     } catch (...) {
102586       {
102587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102588       };
102589     }
102590   }
102591 }
102592
102593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102594   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102595
102596   arg1 = (Dali::Toolkit::WebView *)jarg1;
102597   {
102598     try {
102599       (arg1)->ClearCache();
102600     } catch (std::out_of_range& e) {
102601       {
102602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102603       };
102604     } catch (std::exception& e) {
102605       {
102606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102607       };
102608     } catch (Dali::DaliException e) {
102609       {
102610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102611       };
102612     } catch (...) {
102613       {
102614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102615       };
102616     }
102617   }
102618 }
102619
102620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102621   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102622
102623   arg1 = (Dali::Toolkit::WebView *)jarg1;
102624   {
102625     try {
102626       (arg1)->ClearCookies();
102627     } catch (std::out_of_range& e) {
102628       {
102629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102630       };
102631     } catch (std::exception& e) {
102632       {
102633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102634       };
102635     } catch (Dali::DaliException e) {
102636       {
102637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102638       };
102639     } catch (...) {
102640       {
102641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102642       };
102643     }
102644   }
102645 }
102646
102647 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102648     return (Dali::Toolkit::Control *)jarg1;
102649 }
102650
102651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102652   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102653   SignalConverter::WebViewPageLoadSignal* result = NULL;
102654   {
102655     try {
102656       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102657     } catch (std::out_of_range& e) {
102658       {
102659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102660       };
102661     } catch (std::exception& e) {
102662       {
102663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102664       };
102665     } catch (Dali::DaliException e) {
102666       {
102667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102668       };
102669     } catch (...) {
102670       {
102671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102672       };
102673     }
102674   }
102675   return (void*) result;
102676 }
102677
102678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102679   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102680   SignalConverter::WebViewPageLoadSignal* result = NULL;
102681   {
102682     try {
102683       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102684     } catch (std::out_of_range& e) {
102685       {
102686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102687       };
102688     } catch (std::exception& e) {
102689       {
102690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102691       };
102692     } catch (Dali::DaliException e) {
102693       {
102694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102695       };
102696     } catch (...) {
102697       {
102698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102699       };
102700     }
102701   }
102702   return (void*) result;
102703 }
102704
102705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102706 {
102707   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102708   {
102709     try {
102710       delete object;
102711     } catch (std::out_of_range& e) {
102712       {
102713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102714       };
102715     } catch (std::exception& e) {
102716       {
102717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102718       };
102719     } catch (Dali::DaliException e) {
102720       {
102721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102722       };
102723     } catch (...) {
102724       {
102725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102726       };
102727     }
102728   }
102729 }
102730
102731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102732 {
102733   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102734   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102735   {
102736     try {
102737       proxy->Connect(callback);
102738     } catch (std::out_of_range& e) {
102739       {
102740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102741       };
102742     } catch (std::exception& e) {
102743       {
102744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102745       };
102746     } catch (Dali::DaliException e) {
102747       {
102748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102749       };
102750     } catch (...) {
102751       {
102752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102753       };
102754     }
102755   }
102756 }
102757
102758
102759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102760   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102761   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102762   {
102763     try {
102764       proxy->Disconnect(callback);
102765     } catch (std::out_of_range& e) {
102766       {
102767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102768       };
102769     } catch (std::exception& e) {
102770       {
102771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102772       };
102773     } catch (Dali::DaliException e) {
102774       {
102775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102776       };
102777     } catch (...) {
102778       {
102779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102780       };
102781     }
102782   }
102783 }
102784
102785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102786   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102787   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102788   {
102789     try {
102790       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102791     } catch (std::out_of_range& e) {
102792       {
102793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102794       };
102795     } catch (std::exception& e) {
102796       {
102797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102798       };
102799     } catch (Dali::DaliException e) {
102800       {
102801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102802       };
102803     } catch (...) {
102804       {
102805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102806       };
102807     }
102808   }
102809   return (void*) result;
102810 }
102811
102812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102813 {
102814   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102815   {
102816     try {
102817       delete object;
102818     } catch (std::out_of_range& e) {
102819       {
102820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102821       };
102822     } catch (std::exception& e) {
102823       {
102824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102825       };
102826     } catch (Dali::DaliException e) {
102827       {
102828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102829       };
102830     } catch (...) {
102831       {
102832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102833       };
102834     }
102835   }
102836 }
102837
102838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102839 {
102840   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102841   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102842   {
102843     try {
102844       proxy->Connect(callback);
102845     } catch (std::out_of_range& e) {
102846       {
102847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102848       };
102849     } catch (std::exception& e) {
102850       {
102851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102852       };
102853     } catch (Dali::DaliException e) {
102854       {
102855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102856       };
102857     } catch (...) {
102858       {
102859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102860       };
102861     }
102862   }
102863 }
102864
102865
102866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
102867   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102868   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102869   {
102870     try {
102871       proxy->Disconnect(callback);
102872     } catch (std::out_of_range& e) {
102873       {
102874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102875       };
102876     } catch (std::exception& e) {
102877       {
102878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102879       };
102880     } catch (Dali::DaliException e) {
102881       {
102882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102883       };
102884     } catch (...) {
102885       {
102886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102887       };
102888     }
102889   }
102890 }
102891
102892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
102893   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
102894   char * jresult = SWIG_csharp_string_callback((const char *)result);
102895   return jresult;
102896 }
102897
102898 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
102899   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
102900   return result;
102901 }
102902
102903 #ifdef __cplusplus
102904 }
102905 #endif
102906