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
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 475 #include "web-view-signal-converter.h"
 476
 477
 478 // add here SWIG version check
 479
 480 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 481 // disable Swig-dependent warnings
 482
 483 // 'identifier1' has C-linkage specified,
 484 // but returns UDT 'identifier2' which is incompatible with C
 485 #pragma warning(disable: 4190)
 486
 487 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 488 #pragma warning(disable: 4800)
 489
 490 // debug info too long etc etc
 491 #pragma warning(disable: 4786)
 492 #endif
 493
 494
 495 #include <stdexcept>
 496
 497
 498 #include <string>
 499
 500
 501 #include <vector>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <map>
 507 #include <algorithm>
 508 #include <stdexcept>
 509
 510
 511 #include <utility>
 512
 513
 514 typedef float floatp;
 515
 516 SWIGINTERN floatp *new_floatp(){
 517   return new float();
 518 }
 519 SWIGINTERN void delete_floatp(floatp *self){
 520   if (self) delete self;
 521 }
 522 SWIGINTERN void floatp_assign(floatp *self,float value){
 523   *self = value;
 524 }
 525 SWIGINTERN float floatp_value(floatp *self){
 526   return *self;
 527 }
 528 SWIGINTERN float *floatp_cast(floatp *self){
 529   return self;
 530 }
 531 SWIGINTERN floatp *floatp_frompointer(float *t){
 532   return (floatp *) t;
 533 }
 534
 535 typedef int intp;
 536
 537 SWIGINTERN intp *new_intp(){
 538   return new int();
 539 }
 540 SWIGINTERN void delete_intp(intp *self){
 541   if (self) delete self;
 542 }
 543 SWIGINTERN void intp_assign(intp *self,int value){
 544   *self = value;
 545 }
 546 SWIGINTERN int intp_value(intp *self){
 547   return *self;
 548 }
 549 SWIGINTERN int *intp_cast(intp *self){
 550   return self;
 551 }
 552 SWIGINTERN intp *intp_frompointer(int *t){
 553   return (intp *) t;
 554 }
 555
 556 typedef double doublep;
 557
 558 SWIGINTERN doublep *new_doublep(){
 559   return new double();
 560 }
 561 SWIGINTERN void delete_doublep(doublep *self){
 562   if (self) delete self;
 563 }
 564 SWIGINTERN void doublep_assign(doublep *self,double value){
 565   *self = value;
 566 }
 567 SWIGINTERN double doublep_value(doublep *self){
 568   return *self;
 569 }
 570 SWIGINTERN double *doublep_cast(doublep *self){
 571   return self;
 572 }
 573 SWIGINTERN doublep *doublep_frompointer(double *t){
 574   return (doublep *) t;
 575 }
 576
 577 typedef unsigned int uintp;
 578
 579 SWIGINTERN uintp *new_uintp(){
 580   return new unsigned int();
 581 }
 582 SWIGINTERN void delete_uintp(uintp *self){
 583   if (self) delete self;
 584 }
 585 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 586   *self = value;
 587 }
 588 SWIGINTERN unsigned int uintp_value(uintp *self){
 589   return *self;
 590 }
 591 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 592   return self;
 593 }
 594 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 595   return (uintp *) t;
 596 }
 597
 598 typedef unsigned short ushortp;
 599
 600 SWIGINTERN ushortp *new_ushortp(){
 601   return new unsigned short();
 602 }
 603 SWIGINTERN void delete_ushortp(ushortp *self){
 604   if (self) delete self;
 605 }
 606 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 607   *self = value;
 608 }
 609 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 610   return *self;
 611 }
 612 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 613   return self;
 614 }
 615 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 616   return (ushortp *) t;
 617 }
 618
 619 unsigned int int_to_uint(int x) {
 620    return (unsigned int) x;
 621 }
 622
 623
 624 using namespace Dali;
 625 using namespace Dali::Toolkit;
 626
 627 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 628 {
 629   bool result = false;
 630   try
 631   {
 632     // C++ code. DALi uses Handle <-> Body design pattern.
 633     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 634     // Handles in DALi can be converted into a boolean type
 635     // to check if the handle has a valid body attached to it.
 636     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 637     if( *self )
 638     {
 639       result = true;
 640     }
 641     else
 642     {
 643       result = false;
 644     }
 645   }
 646   catch (std::out_of_range& e)
 647   {
 648     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 649     return 0;
 650   }
 651   catch (std::exception& e)
 652   {
 653     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 654     return 0;
 655   }
 656   catch (DaliException e)
 657   {
 658     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 659     return 0;
 660   }
 661   catch (...)
 662   {
 663     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 664     return 0;
 665   }
 666   return result;
 667 }
 668
 669 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 670 {
 671   bool result = false;
 672   try
 673   {
 674     // C++ code. Check if two handles reference the same implemtion
 675     if( *self == rhs)
 676     {
 677       result = true;
 678     }
 679     else
 680     {
 681       result = false;
 682     }
 683   }
 684   catch (std::out_of_range& e)
 685   {
 686     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 687     return 0;
 688   }
 689   catch (std::exception& e)
 690   {
 691     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 692     return 0;
 693   }
 694   catch (DaliException e)
 695   {
 696     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 697     return 0;
 698   }
 699   catch (...)
 700   {
 701     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 702     return 0;
 703   }
 704   return result;
 705 }
 706
 707
 708 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 709      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 710    }
 711 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){
 712      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 713    }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 715         std::vector< Dali::TouchPoint >* pv = 0;
 716         if (capacity >= 0) {
 717           pv = new std::vector< Dali::TouchPoint >();
 718           pv->reserve(capacity);
 719        } else {
 720           throw std::out_of_range("capacity");
 721        }
 722        return pv;
 723       }
 724 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 725         if (index>=0 && index<(int)self->size())
 726           return (*self)[index];
 727         else
 728           throw std::out_of_range("index");
 729       }
 730 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 737         if (index>=0 && index<(int)self->size())
 738           (*self)[index] = val;
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 743         self->insert(self->end(), values.begin(), values.end());
 744       }
 745 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 746         if (index < 0)
 747           throw std::out_of_range("index");
 748         if (count < 0)
 749           throw std::out_of_range("count");
 750         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 751           throw std::invalid_argument("invalid range");
 752         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, x);
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, values.begin(), values.end());
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 767         if (index>=0 && index<(int)self->size())
 768           self->erase(self->begin() + index);
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 773         if (index < 0)
 774           throw std::out_of_range("index");
 775         if (count < 0)
 776           throw std::out_of_range("count");
 777         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 778           throw std::invalid_argument("invalid range");
 779         self->erase(self->begin()+index, self->begin()+index+count);
 780       }
 781 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 782         if (count < 0)
 783           throw std::out_of_range("count");
 784         return new std::vector< Dali::TouchPoint >(count, value);
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 787         std::reverse(self->begin(), self->end());
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         std::reverse(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 799         if (index < 0)
 800           throw std::out_of_range("index");
 801         if (index+values.size() > self->size())
 802           throw std::out_of_range("index");
 803         std::copy(values.begin(), values.end(), self->begin()+index);
 804       }
 805 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 806          return self->Empty();
 807       }
 808 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 809         return self->GetConnectionCount();
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Connect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Disconnect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 818           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 819 /*@SWIG@*/ self->Emit( arg );
 820       }
 821 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822          return self->Empty();
 823       }
 824 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825         return self->GetConnectionCount();
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Connect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Disconnect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 834           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 835 /*@SWIG@*/ self->Emit( arg );
 836       }
 837 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 838          return self->Empty();
 839       }
 840 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){
 841         return self->GetConnectionCount();
 842       }
 843 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 *)){
 844           self->Connect( func );
 845       }
 846 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 *)){
 847           self->Disconnect( func );
 848       }
 849 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){
 850           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 851 /*@SWIG@*/ self->Emit( arg );
 852       }
 853 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854          return self->Empty();
 855       }
 856 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857         return self->GetConnectionCount();
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Connect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Disconnect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 866           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 867 /*@SWIG@*/ self->Emit( arg );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Disconnect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 882           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 883 /*@SWIG@*/ self->Emit( arg );
 884       }
 885 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){
 886          return self->Empty();
 887       }
 888 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){
 889         return self->GetConnectionCount();
 890       }
 891 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 &)){
 892         self->Connect( func );
 893       }
 894 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 &)){
 895         self->Disconnect( func );
 896       }
 897 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){
 898         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg1, arg2 );
 900       }
 901 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){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908         self->Connect( func );
 909       }
 910 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 &)){
 911         self->Disconnect( func );
 912       }
 913 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){
 914         return self->Emit( arg1, arg2 );
 915       }
 916 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){
 917          return self->Empty();
 918       }
 919 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){
 920         return self->GetConnectionCount();
 921       }
 922 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 &)){
 923         self->Connect( func );
 924       }
 925 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 &)){
 926         self->Disconnect( func );
 927       }
 928 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){
 929         return self->Emit( arg1, arg2 );
 930       }
 931 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){
 932          return self->Empty();
 933       }
 934 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){
 935         return self->GetConnectionCount();
 936       }
 937 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 &)){
 938         self->Connect( func );
 939       }
 940 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 &)){
 941         self->Disconnect( func );
 942       }
 943 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){
 944         return self->Emit( arg1, arg2 );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 947          return self->Empty();
 948       }
 949 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 950         return self->GetConnectionCount();
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Connect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Disconnect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 959           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 960 /*@SWIG@*/ self->Emit( arg );
 961       }
 962 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 963          return self->Empty();
 964       }
 965 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){
 966         return self->GetConnectionCount();
 967       }
 968 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 &)){
 969           self->Connect( func );
 970       }
 971 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 &)){
 972           self->Disconnect( func );
 973       }
 974 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){
 975           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 976 /*@SWIG@*/ self->Emit( arg );
 977       }
 978 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 979          return self->Empty();
 980       }
 981 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){
 982         return self->GetConnectionCount();
 983       }
 984 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 &)){
 985           self->Connect( func );
 986       }
 987 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 &)){
 988           self->Disconnect( func );
 989       }
 990 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){
 991           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 992 /*@SWIG@*/ self->Emit( arg );
 993       }
 994 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 995          return self->Empty();
 996       }
 997 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){
 998         return self->GetConnectionCount();
 999       }
1000 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 &)){
1001           self->Connect( func );
1002       }
1003 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 &)){
1004           self->Disconnect( func );
1005       }
1006 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){
1007           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1008 /*@SWIG@*/ self->Emit( arg );
1009       }
1010 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){
1011          return self->Empty();
1012       }
1013 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){
1014         return self->GetConnectionCount();
1015       }
1016 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 &)){
1017         self->Connect( func );
1018       }
1019 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 &)){
1020         self->Disconnect( func );
1021       }
1022 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){
1023         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1024 /*@SWIG@*/ self->Emit( arg1, arg2 );
1025       }
1026 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){
1027          return self->Empty();
1028       }
1029 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){
1030         return self->GetConnectionCount();
1031       }
1032 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 &)){
1033         self->Connect( func );
1034       }
1035 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 &)){
1036         self->Disconnect( func );
1037       }
1038 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){
1039         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1040 /*@SWIG@*/ self->Emit( arg1, arg2 );
1041       }
1042 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){
1043          return self->Empty();
1044       }
1045 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){
1046         return self->GetConnectionCount();
1047       }
1048 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 &)){
1049         self->Connect( func );
1050       }
1051 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 &)){
1052         self->Disconnect( func );
1053       }
1054 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){
1055         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1056 /*@SWIG@*/ self->Emit( arg1, arg2 );
1057       }
1058 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059          return self->Empty();
1060       }
1061 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062         return self->GetConnectionCount();
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Connect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Disconnect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1071           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1072 /*@SWIG@*/ self->Emit( arg );
1073       }
1074 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){
1075          return self->Empty();
1076       }
1077 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){
1078         return self->GetConnectionCount();
1079       }
1080 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)){
1081           return self->Connect( func );
1082       }
1083 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)){
1084           self->Disconnect( func );
1085       }
1086 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){
1087           self->Emit( arg1, arg3 );
1088       }
1089 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){
1090          return self->Empty();
1091       }
1092 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){
1093         return self->GetConnectionCount();
1094       }
1095 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)){
1096           return self->Connect( func );
1097       }
1098 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)){
1099           self->Disconnect( func );
1100       }
1101 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){
1102           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1103 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1104       }
1105
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1107          return self->Empty();
1108       }
1109 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1110         return self->GetConnectionCount();
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Connect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Disconnect( func );
1117       }
1118 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1119           return self->Emit();
1120       }
1121
1122 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1123         std::vector< unsigned int >* pv = 0;
1124         if (capacity >= 0) {
1125           pv = new std::vector< unsigned int >();
1126           pv->reserve(capacity);
1127        } else {
1128           throw std::out_of_range("capacity");
1129        }
1130        return pv;
1131       }
1132 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1145         if (index>=0 && index<(int)self->size())
1146           (*self)[index] = val;
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1151         self->insert(self->end(), values.begin(), values.end());
1152       }
1153 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, x);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, values.begin(), values.end());
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1175         if (index>=0 && index<(int)self->size())
1176           self->erase(self->begin() + index);
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1186           throw std::invalid_argument("invalid range");
1187         self->erase(self->begin()+index, self->begin()+index+count);
1188       }
1189 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         return new std::vector< unsigned int >(count, value);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1195         std::reverse(self->begin(), self->end());
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         std::reverse(self->begin()+index, self->begin()+index+count);
1205       }
1206 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1207         if (index < 0)
1208           throw std::out_of_range("index");
1209         if (index+values.size() > self->size())
1210           throw std::out_of_range("index");
1211         std::copy(values.begin(), values.end(), self->begin()+index);
1212       }
1213 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1214         return std::find(self->begin(), self->end(), value) != self->end();
1215       }
1216 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1217         int index = -1;
1218         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1219         if (it != self->end())
1220           index = (int)(it - self->begin());
1221         return index;
1222       }
1223 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1224         int index = -1;
1225         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1226         if (rit != self->rend())
1227           index = (int)(self->rend() - 1 - rit);
1228         return index;
1229       }
1230 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1231         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1232         if (it != self->end()) {
1233           self->erase(it);
1234           return true;
1235         }
1236         return false;
1237       }
1238 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){
1239         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1240         if (capacity >= 0) {
1241           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1242           pv->reserve(capacity);
1243        } else {
1244           throw std::out_of_range("capacity");
1245        }
1246        return pv;
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           return (*self)[index];
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         if (index>=0 && index<(int)self->size())
1262           (*self)[index] = val;
1263         else
1264           throw std::out_of_range("index");
1265       }
1266 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){
1267         self->insert(self->end(), values.begin(), values.end());
1268       }
1269 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){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, x);
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size()+1)
1286           self->insert(self->begin()+index, values.begin(), values.end());
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
1291         if (index>=0 && index<(int)self->size())
1292           self->erase(self->begin() + index);
1293         else
1294           throw std::out_of_range("index");
1295       }
1296 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){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1302           throw std::invalid_argument("invalid range");
1303         self->erase(self->begin()+index, self->begin()+index+count);
1304       }
1305 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){
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1309       }
1310 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){
1311         std::reverse(self->begin(), self->end());
1312       }
1313 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){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         std::reverse(self->begin()+index, self->begin()+index+count);
1321       }
1322 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){
1323         if (index < 0)
1324           throw std::out_of_range("index");
1325         if (index+values.size() > self->size())
1326           throw std::out_of_range("index");
1327         std::copy(values.begin(), values.end(), self->begin()+index);
1328       }
1329 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1330         std::vector< Dali::Actor >* pv = 0;
1331         if (capacity >= 0) {
1332           pv = new std::vector< Dali::Actor >();
1333           pv->reserve(capacity);
1334        } else {
1335           throw std::out_of_range("capacity");
1336        }
1337        return pv;
1338       }
1339 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1346         if (index>=0 && index<(int)self->size())
1347           return (*self)[index];
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1352         if (index>=0 && index<(int)self->size())
1353           (*self)[index] = val;
1354         else
1355           throw std::out_of_range("index");
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1358         self->insert(self->end(), values.begin(), values.end());
1359       }
1360 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, x);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1376         if (index>=0 && index<(int)self->size()+1)
1377           self->insert(self->begin()+index, values.begin(), values.end());
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1382         if (index>=0 && index<(int)self->size())
1383           self->erase(self->begin() + index);
1384         else
1385           throw std::out_of_range("index");
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (count < 0)
1391           throw std::out_of_range("count");
1392         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1393           throw std::invalid_argument("invalid range");
1394         self->erase(self->begin()+index, self->begin()+index+count);
1395       }
1396 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         return new std::vector< Dali::Actor >(count, value);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1402         std::reverse(self->begin(), self->end());
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1405         if (index < 0)
1406           throw std::out_of_range("index");
1407         if (count < 0)
1408           throw std::out_of_range("count");
1409         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1410           throw std::invalid_argument("invalid range");
1411         std::reverse(self->begin()+index, self->begin()+index+count);
1412       }
1413 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1414         if (index < 0)
1415           throw std::out_of_range("index");
1416         if (index+values.size() > self->size())
1417           throw std::out_of_range("index");
1418         std::copy(values.begin(), values.end(), self->begin()+index);
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 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 &)){
1427           self->Connect( func );
1428       }
1429 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 &)){
1430           self->Disconnect( func );
1431       }
1432 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){
1433           return self->Emit( arg );
1434       }
1435 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){
1436          return self->Empty();
1437       }
1438 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){
1439         return self->GetConnectionCount();
1440       }
1441 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)){
1442         self->Connect( func );
1443       }
1444 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)){
1445         self->Disconnect( func );
1446       }
1447 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){
1448         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1449 /*@SWIG@*/ self->Emit( arg1, arg2 );
1450       }
1451 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452          return self->Empty();
1453       }
1454 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){
1455         return self->GetConnectionCount();
1456       }
1457 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)){
1458         self->Connect( func );
1459       }
1460 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)){
1461         self->Disconnect( func );
1462       }
1463 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){
1464         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1465 /*@SWIG@*/ self->Emit( arg1, arg2 );
1466       }
1467 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468          return self->Empty();
1469       }
1470 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471         return self->GetConnectionCount();
1472       }
1473 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)){
1474         self->Connect( func );
1475       }
1476 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)){
1477         self->Disconnect( func );
1478       }
1479 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){
1480         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1481 /*@SWIG@*/ self->Emit( arg1, arg2 );
1482       }
1483 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){
1484          return self->Empty();
1485       }
1486 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){
1487         return self->GetConnectionCount();
1488       }
1489 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)){
1490         self->Connect( func );
1491       }
1492 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)){
1493         self->Disconnect( func );
1494       }
1495 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){
1496         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1497 /*@SWIG@*/ self->Emit( arg1, arg2 );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 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)){
1506           self->Connect( func );
1507       }
1508 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)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1512           return self->Emit( arg );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 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)){
1521           self->Connect( func );
1522       }
1523 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)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 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){
1531          return self->Empty();
1532       }
1533 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){
1534         return self->GetConnectionCount();
1535       }
1536 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)){
1537           return self->Connect( func );
1538       }
1539 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)){
1540           self->Disconnect( func );
1541       }
1542 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){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547          return self->Empty();
1548       }
1549 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550         return self->GetConnectionCount();
1551       }
1552 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)){
1553           self->Connect( func );
1554       }
1555 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)){
1556           self->Disconnect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1559           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1560 /*@SWIG@*/ self->Emit( arg );
1561       }
1562 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){
1563          return self->Empty();
1564       }
1565 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){
1566         return self->GetConnectionCount();
1567       }
1568 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)){
1569           return self->Connect( func );
1570       }
1571 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)){
1572           self->Disconnect( func );
1573       }
1574 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){
1575           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1576 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1577       }
1578 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){
1579          return self->Empty();
1580       }
1581 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){
1582         return self->GetConnectionCount();
1583       }
1584 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 &)){
1585           self->Connect( func );
1586       }
1587 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 &)){
1588           self->Disconnect( func );
1589       }
1590 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){
1591           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1592 /*@SWIG@*/ self->Emit( arg );
1593       }
1594 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595          return self->Empty();
1596       }
1597 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){
1598         return self->GetConnectionCount();
1599       }
1600 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 &)){
1601           self->Connect( func );
1602       }
1603 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 &)){
1604           self->Disconnect( func );
1605       }
1606 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){
1607           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1608 /*@SWIG@*/ self->Emit( arg );
1609       }
1610
1611
1612 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){
1613          return self->Empty();
1614       }
1615 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){
1616         return self->GetConnectionCount();
1617       }
1618 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 &)){
1619         self->Connect( func );
1620       }
1621 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 &)){
1622         self->Disconnect( func );
1623       }
1624 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){
1625         return self->Emit( arg1, arg2 );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628          return self->Empty();
1629       }
1630 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631         return self->GetConnectionCount();
1632       }
1633 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)){
1634           self->Connect( func );
1635       }
1636 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)){
1637           self->Disconnect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1640           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1641 /*@SWIG@*/ self->Emit( arg );
1642       }
1643 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644          return self->Empty();
1645       }
1646 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647         return self->GetConnectionCount();
1648       }
1649 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 &)){
1650           self->Connect( func );
1651       }
1652 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 &)){
1653           self->Disconnect( func );
1654       }
1655 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){
1656           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1657 /*@SWIG@*/ self->Emit( arg );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1660          return self->Empty();
1661       }
1662 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){
1663         return self->GetConnectionCount();
1664       }
1665 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)){
1666         self->Connect( func );
1667       }
1668 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)){
1669         self->Disconnect( func );
1670       }
1671 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){
1672         return self->Emit( arg1, arg2 );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1675          return self->Empty();
1676       }
1677 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){
1678         return self->GetConnectionCount();
1679       }
1680 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)){
1681         self->Connect( func );
1682       }
1683 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)){
1684         self->Disconnect( func );
1685       }
1686 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){
1687         return self->Emit( arg1, arg2 );
1688       }
1689
1690 /* ---------------------------------------------------
1691  * C++ director class methods
1692  * --------------------------------------------------- */
1693
1694 #include "dali_wrap.h"
1695
1696 /*
1697  *  Widget director
1698  */
1699 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1700   swig_init_callbacks();
1701 }
1702
1703 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1707   char * jcontentInfo = 0 ;
1708   void * jwindow  ;
1709
1710   if (!swig_callbackOnCreate) {
1711     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1716     swig_callbackOnCreate(jcontentInfo, jwindow);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1721   char * jcontentInfo = 0 ;
1722   int jtype  ;
1723
1724   if (!swig_callbackOnTerminate) {
1725     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1726     return;
1727   } else {
1728     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1729     jtype = (int)type;
1730     swig_callbackOnTerminate(jcontentInfo, jtype);
1731   }
1732 }
1733
1734 void SwigDirector_WidgetImpl::OnPause() {
1735   if (!swig_callbackOnPause) {
1736     Dali::Internal::Adaptor::Widget::OnPause();
1737     return;
1738   } else {
1739     swig_callbackOnPause();
1740   }
1741 }
1742
1743 void SwigDirector_WidgetImpl::OnResume() {
1744   if (!swig_callbackOnResume) {
1745     Dali::Internal::Adaptor::Widget::OnResume();
1746     return;
1747   } else {
1748     swig_callbackOnResume();
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1753   void * jwindow  ;
1754
1755   if (!swig_callbackOnResize) {
1756     Dali::Internal::Adaptor::Widget::OnResize(window);
1757     return;
1758   } else {
1759     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1760     swig_callbackOnResize(jwindow);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1765   char * jcontentInfo = 0 ;
1766   int jforce  ;
1767
1768   if (!swig_callbackOnUpdate) {
1769     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1770     return;
1771   } else {
1772     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1773     jforce = force;
1774     swig_callbackOnUpdate(jcontentInfo, jforce);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalConnected) {
1783     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalConnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1793   void * jslotObserver = 0 ;
1794   void * jcallback = 0 ;
1795
1796   if (!swig_callbackSignalDisconnected) {
1797     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1798     return;
1799   } else {
1800     jslotObserver = (void *) slotObserver;
1801     jcallback = (void *) callback;
1802     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1803   }
1804 }
1805
1806 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) {
1807
1808   swig_callbackOnCreate = callbackOnCreate;
1809   swig_callbackOnTerminate = callbackOnTerminate;
1810   swig_callbackOnPause = callbackOnPause;
1811   swig_callbackOnResume = callbackOnResume;
1812   swig_callbackOnResize = callbackOnResize;
1813   swig_callbackOnUpdate = callbackOnUpdate;
1814   swig_callbackSignalConnected = callbackSignalConnected;
1815   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1816 }
1817
1818 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1819   swig_callbackOnCreate = 0;
1820   swig_callbackOnTerminate = 0;
1821   swig_callbackOnPause = 0;
1822   swig_callbackOnResume = 0;
1823   swig_callbackOnResize = 0;
1824   swig_callbackOnUpdate = 0;
1825   swig_callbackSignalConnected = 0;
1826   swig_callbackSignalDisconnected = 0;
1827 }
1828
1829
1830 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1831   swig_init_callbacks();
1832 }
1833
1834 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1835
1836 }
1837
1838
1839 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1840   int jdepth  ;
1841
1842   if (!swig_callbackOnStageConnection) {
1843     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1844     return;
1845   } else {
1846     jdepth = depth;
1847     swig_callbackOnStageConnection(jdepth);
1848   }
1849 }
1850
1851 void SwigDirector_ViewImpl::OnStageDisconnection() {
1852   if (!swig_callbackOnStageDisconnection) {
1853     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1854     return;
1855   } else {
1856     swig_callbackOnStageDisconnection();
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildAdd) {
1864     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildAdd(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1873   void * jchild = 0 ;
1874
1875   if (!swig_callbackOnChildRemove) {
1876     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1877     return;
1878   } else {
1879     jchild = (Dali::Actor *) &child;
1880     swig_callbackOnChildRemove(jchild);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1885   int jindex  ;
1886   void * jpropertyValue  ;
1887
1888   if (!swig_callbackOnPropertySet) {
1889     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1890     return;
1891   } else {
1892     jindex = index;
1893     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1894     swig_callbackOnPropertySet(jindex, jpropertyValue);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1899   void * jtargetSize = 0 ;
1900
1901   if (!swig_callbackOnSizeSet) {
1902     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1903     return;
1904   } else {
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeSet(jtargetSize);
1907   }
1908 }
1909
1910 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1911   void * janimation = 0 ;
1912   void * jtargetSize = 0 ;
1913
1914   if (!swig_callbackOnSizeAnimation) {
1915     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1916     return;
1917   } else {
1918     janimation = (Dali::Animation *) &animation;
1919     jtargetSize = (Dali::Vector3 *) &targetSize;
1920     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1921   }
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnTouchEvent) {
1930     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1931   } else {
1932     jarg0 = (Dali::TouchEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnHoverEvent) {
1945     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1946   } else {
1947     jarg0 = (Dali::HoverEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnKeyEvent) {
1960     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1961   } else {
1962     jarg0 = (Dali::KeyEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1970   bool c_result = SwigValueInit< bool >() ;
1971   unsigned int jresult = 0 ;
1972   void * jarg0 = 0 ;
1973
1974   if (!swig_callbackOnWheelEvent) {
1975     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1976   } else {
1977     jarg0 = (Dali::WheelEvent *) &event;
1978     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1979     c_result = jresult ? true : false;
1980   }
1981   return c_result;
1982 }
1983
1984 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1985   void * jsize = 0 ;
1986   void * jcontainer = 0 ;
1987
1988   if (!swig_callbackOnRelayout) {
1989     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1990     return;
1991   } else {
1992     jsize = (Dali::Vector2 *) &size;
1993     jcontainer = (Dali::RelayoutContainer *) &container;
1994     swig_callbackOnRelayout(jsize, jcontainer);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1999   int jpolicy  ;
2000   int jdimension  ;
2001
2002   if (!swig_callbackOnSetResizePolicy) {
2003     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2004     return;
2005   } else {
2006     jpolicy = (int)policy;
2007     jdimension = (int)dimension;
2008     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2009   }
2010 }
2011
2012 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2013   Dali::Vector3 c_result ;
2014   void * jresult = 0 ;
2015
2016   if (!swig_callbackGetNaturalSize) {
2017     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2018   } else {
2019     jresult = (void *) swig_callbackGetNaturalSize();
2020     if (!jresult) {
2021       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2022       return c_result;
2023     }
2024     c_result = *(Dali::Vector3 *)jresult;
2025   }
2026   return c_result;
2027 }
2028
2029 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2030   float c_result = SwigValueInit< float >() ;
2031   float jresult = 0 ;
2032   void * jchild = 0 ;
2033   int jdimension  ;
2034
2035   if (!swig_callbackCalculateChildSize) {
2036     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2037   } else {
2038     jchild = (Dali::Actor *) &child;
2039     jdimension = (int)dimension;
2040     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jwidth  ;
2050
2051   if (!swig_callbackGetHeightForWidth) {
2052     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2053   } else {
2054     jwidth = width;
2055     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2062   float c_result = SwigValueInit< float >() ;
2063   float jresult = 0 ;
2064   float jheight  ;
2065
2066   if (!swig_callbackGetWidthForHeight) {
2067     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2068   } else {
2069     jheight = height;
2070     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2071     c_result = (float)jresult;
2072   }
2073   return c_result;
2074 }
2075
2076 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2077   bool c_result = SwigValueInit< bool >() ;
2078   unsigned int jresult = 0 ;
2079   int jdimension  ;
2080
2081   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2082     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2083   } else {
2084     jdimension = (int)dimension;
2085     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2086     c_result = jresult ? true : false;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2092   int jdimension  ;
2093
2094   if (!swig_callbackOnCalculateRelayoutSize) {
2095     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2096     return;
2097   } else {
2098     jdimension = (int)dimension;
2099     swig_callbackOnCalculateRelayoutSize(jdimension);
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2104   float jsize  ;
2105   int jdimension  ;
2106
2107   if (!swig_callbackOnLayoutNegotiated) {
2108     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2109     return;
2110   } else {
2111     jsize = size;
2112     jdimension = (int)dimension;
2113     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2114   }
2115 }
2116
2117 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2118   return Dali::CustomActorImpl::GetExtension();
2119 }
2120
2121 void SwigDirector_ViewImpl::OnInitialize() {
2122   if (!swig_callbackOnInitialize) {
2123     Dali::Toolkit::Internal::Control::OnInitialize();
2124     return;
2125   } else {
2126     swig_callbackOnInitialize();
2127   }
2128 }
2129
2130 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2131   void * jchild = 0 ;
2132
2133   if (!swig_callbackOnControlChildAdd) {
2134     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2135     return;
2136   } else {
2137     jchild = (Dali::Actor *) &child;
2138     swig_callbackOnControlChildAdd(jchild);
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2143   void * jchild = 0 ;
2144
2145   if (!swig_callbackOnControlChildRemove) {
2146     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2147     return;
2148   } else {
2149     jchild = (Dali::Actor *) &child;
2150     swig_callbackOnControlChildRemove(jchild);
2151   }
2152 }
2153
2154 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2155   void * jstyleManager  ;
2156   int jchange  ;
2157
2158   if (!swig_callbackOnStyleChange) {
2159     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2160     return;
2161   } else {
2162     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2163     jchange = (int)change;
2164     swig_callbackOnStyleChange(jstyleManager, jchange);
2165   }
2166 }
2167
2168 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2169   bool c_result = SwigValueInit< bool >() ;
2170   unsigned int jresult = 0 ;
2171
2172   if (!swig_callbackOnAccessibilityActivated) {
2173     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2174   } else {
2175     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2176     c_result = jresult ? true : false;
2177   }
2178   return c_result;
2179 }
2180
2181 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2182   bool c_result = SwigValueInit< bool >() ;
2183   unsigned int jresult = 0 ;
2184   void * jgesture  ;
2185
2186   if (!swig_callbackOnAccessibilityPan) {
2187     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2188   } else {
2189     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2190     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2191     c_result = jresult ? true : false;
2192   }
2193   return c_result;
2194 }
2195
2196 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2197   bool c_result = SwigValueInit< bool >() ;
2198   unsigned int jresult = 0 ;
2199   void * jtouchEvent = 0 ;
2200
2201   if (!swig_callbackOnAccessibilityTouch) {
2202     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2203   } else {
2204     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2205     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2206     c_result = jresult ? true : false;
2207   }
2208   return c_result;
2209 }
2210
2211 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2212   bool c_result = SwigValueInit< bool >() ;
2213   unsigned int jresult = 0 ;
2214   unsigned int jisIncrease  ;
2215
2216   if (!swig_callbackOnAccessibilityValueChange) {
2217     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2218   } else {
2219     jisIncrease = isIncrease;
2220     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2221     c_result = jresult ? true : false;
2222   }
2223   return c_result;
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnAccessibilityZoom) {
2231     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2240   if (!swig_callbackOnKeyInputFocusGained) {
2241     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2242     return;
2243   } else {
2244     swig_callbackOnKeyInputFocusGained();
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2249   if (!swig_callbackOnKeyInputFocusLost) {
2250     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2251     return;
2252   } else {
2253     swig_callbackOnKeyInputFocusLost();
2254   }
2255 }
2256
2257 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2258   Dali::Actor c_result ;
2259   void * jresult = 0 ;
2260   void * jcurrentFocusedActor  ;
2261   int jdirection  ;
2262   unsigned int jloopEnabled  ;
2263
2264   if (!swig_callbackGetNextKeyboardFocusableActor) {
2265     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2266   } else {
2267     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2268     jdirection = (int)direction;
2269     jloopEnabled = loopEnabled;
2270     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2271     if (!jresult) {
2272       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2273       return c_result;
2274     }
2275     c_result = *(Dali::Actor *)jresult;
2276   }
2277   return c_result;
2278 }
2279
2280 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2281   void * jcommitedFocusableActor  ;
2282
2283   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2284     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2285     return;
2286   } else {
2287     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2288     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2289   }
2290 }
2291
2292 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2293   bool c_result = SwigValueInit< bool >() ;
2294   unsigned int jresult = 0 ;
2295
2296   if (!swig_callbackOnKeyboardEnter) {
2297     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2298   } else {
2299     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2300     c_result = jresult ? true : false;
2301   }
2302   return c_result;
2303 }
2304
2305 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2306   void * jpinch = 0 ;
2307
2308   if (!swig_callbackOnPinch) {
2309     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2310     return;
2311   } else {
2312     jpinch = (Dali::PinchGesture *) &pinch;
2313     swig_callbackOnPinch(jpinch);
2314   }
2315 }
2316
2317 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2318   void * jpan = 0 ;
2319
2320   if (!swig_callbackOnPan) {
2321     Dali::Toolkit::Internal::Control::OnPan(pan);
2322     return;
2323   } else {
2324     jpan = (Dali::PanGesture *) &pan;
2325     swig_callbackOnPan(jpan);
2326   }
2327 }
2328
2329 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2330   void * jtap = 0 ;
2331
2332   if (!swig_callbackOnTap) {
2333     Dali::Toolkit::Internal::Control::OnTap(tap);
2334     return;
2335   } else {
2336     jtap = (Dali::TapGesture *) &tap;
2337     swig_callbackOnTap(jtap);
2338   }
2339 }
2340
2341 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2342   void * jlongPress = 0 ;
2343
2344   if (!swig_callbackOnLongPress) {
2345     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2346     return;
2347   } else {
2348     jlongPress = (Dali::LongPressGesture *) &longPress;
2349     swig_callbackOnLongPress(jlongPress);
2350   }
2351 }
2352
2353 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2354   void * jslotObserver = 0 ;
2355   void * jcallback = 0 ;
2356
2357   if (!swig_callbackSignalConnected) {
2358     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2359     return;
2360   } else {
2361     jslotObserver = (void *) slotObserver;
2362     jcallback = (void *) callback;
2363     swig_callbackSignalConnected(jslotObserver, jcallback);
2364   }
2365 }
2366
2367 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2368   void * jslotObserver = 0 ;
2369   void * jcallback = 0 ;
2370
2371   if (!swig_callbackSignalDisconnected) {
2372     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2373     return;
2374   } else {
2375     jslotObserver = (void *) slotObserver;
2376     jcallback = (void *) callback;
2377     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2378   }
2379 }
2380
2381 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2382   return Dali::Toolkit::Internal::Control::GetControlExtension();
2383 }
2384
2385 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) {
2386   swig_callbackOnStageConnection = callbackOnStageConnection;
2387   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2388   swig_callbackOnChildAdd = callbackOnChildAdd;
2389   swig_callbackOnChildRemove = callbackOnChildRemove;
2390   swig_callbackOnPropertySet = callbackOnPropertySet;
2391   swig_callbackOnSizeSet = callbackOnSizeSet;
2392   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2393   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2394   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2395   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2396   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2397   swig_callbackOnRelayout = callbackOnRelayout;
2398   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2399   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2400   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2401   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2402   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2403   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2405   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2406   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2407   swig_callbackOnInitialize = callbackOnInitialize;
2408   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2409   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2410   swig_callbackOnStyleChange = callbackOnStyleChange;
2411   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2412   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2413   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2414   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2415   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2416   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2417   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2418   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2419   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2420   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2421   swig_callbackOnPinch = callbackOnPinch;
2422   swig_callbackOnPan = callbackOnPan;
2423   swig_callbackOnTap = callbackOnTap;
2424   swig_callbackOnLongPress = callbackOnLongPress;
2425   swig_callbackSignalConnected = callbackSignalConnected;
2426   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2427 }
2428
2429 void SwigDirector_ViewImpl::swig_init_callbacks() {
2430   swig_callbackOnStageConnection = 0;
2431   swig_callbackOnStageDisconnection = 0;
2432   swig_callbackOnChildAdd = 0;
2433   swig_callbackOnChildRemove = 0;
2434   swig_callbackOnPropertySet = 0;
2435   swig_callbackOnSizeSet = 0;
2436   swig_callbackOnSizeAnimation = 0;
2437   swig_callbackOnTouchEvent = 0;
2438   swig_callbackOnHoverEvent = 0;
2439   swig_callbackOnKeyEvent = 0;
2440   swig_callbackOnWheelEvent = 0;
2441   swig_callbackOnRelayout = 0;
2442   swig_callbackOnSetResizePolicy = 0;
2443   swig_callbackGetNaturalSize = 0;
2444   swig_callbackCalculateChildSize = 0;
2445   swig_callbackGetHeightForWidth = 0;
2446   swig_callbackGetWidthForHeight = 0;
2447   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2449   swig_callbackOnCalculateRelayoutSize = 0;
2450   swig_callbackOnLayoutNegotiated = 0;
2451   swig_callbackOnInitialize = 0;
2452   swig_callbackOnControlChildAdd = 0;
2453   swig_callbackOnControlChildRemove = 0;
2454   swig_callbackOnStyleChange = 0;
2455   swig_callbackOnAccessibilityActivated = 0;
2456   swig_callbackOnAccessibilityPan = 0;
2457   swig_callbackOnAccessibilityTouch = 0;
2458   swig_callbackOnAccessibilityValueChange = 0;
2459   swig_callbackOnAccessibilityZoom = 0;
2460   swig_callbackOnKeyInputFocusGained = 0;
2461   swig_callbackOnKeyInputFocusLost = 0;
2462   swig_callbackGetNextKeyboardFocusableActor = 0;
2463   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2464   swig_callbackOnKeyboardEnter = 0;
2465   swig_callbackOnPinch = 0;
2466   swig_callbackOnPan = 0;
2467   swig_callbackOnTap = 0;
2468   swig_callbackOnLongPress = 0;
2469   swig_callbackSignalConnected = 0;
2470   swig_callbackSignalDisconnected = 0;
2471 }
2472
2473 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2474   swig_init_callbacks();
2475 }
2476
2477 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2478
2479 }
2480
2481
2482 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2483   unsigned int c_result = SwigValueInit< unsigned int >() ;
2484   unsigned int jresult = 0 ;
2485
2486   if (!swig_callbackGetNumberOfItems) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2488   } else {
2489     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2490     c_result = (unsigned int)jresult;
2491   }
2492   return c_result;
2493 }
2494
2495 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2496   Dali::Actor c_result ;
2497   void * jresult = 0 ;
2498   unsigned int jitemId  ;
2499
2500   if (!swig_callbackNewItem) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2502   } else {
2503     jitemId = itemId;
2504     jresult = (void *) swig_callbackNewItem(jitemId);
2505     if (!jresult) {
2506       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2507       return c_result;
2508     }
2509     c_result = *(Dali::Actor *)jresult;
2510   }
2511   return c_result;
2512 }
2513
2514 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2515   unsigned int jitemId  ;
2516   void * jactor  ;
2517
2518   if (!swig_callbackItemReleased) {
2519     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2520     return;
2521   } else {
2522     jitemId = itemId;
2523     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2524     swig_callbackItemReleased(jitemId, jactor);
2525   }
2526 }
2527
2528 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2529   return Dali::Toolkit::ItemFactory::GetExtension();
2530 }
2531
2532 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2533   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2534   swig_callbackNewItem = callbackNewItem;
2535   swig_callbackItemReleased = callbackItemReleased;
2536 }
2537
2538 void SwigDirector_ItemFactory::swig_init_callbacks() {
2539   swig_callbackGetNumberOfItems = 0;
2540   swig_callbackNewItem = 0;
2541   swig_callbackItemReleased = 0;
2542 }
2543
2544 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2545   swig_init_callbacks();
2546 }
2547
2548 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2549
2550 }
2551
2552
2553 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2554   Dali::Actor c_result ;
2555   void * jresult = 0 ;
2556   void * jcurrent  ;
2557   void * jproposed  ;
2558   int jdirection  ;
2559
2560   if (!swig_callbackGetNextFocusableActor) {
2561     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2562   } else {
2563     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2564     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2565     jdirection = (int)direction;
2566     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2567     if (!jresult) {
2568       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2569       return c_result;
2570     }
2571     c_result = *(Dali::Actor *)jresult;
2572   }
2573   return c_result;
2574 }
2575
2576 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2577   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2578 }
2579
2580 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2581   swig_callbackGetNextFocusableActor = 0;
2582 }
2583
2584
2585 #ifdef __cplusplus
2586 extern "C" {
2587 #endif
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2590   void * jresult ;
2591   floatp *result = 0 ;
2592
2593   {
2594     try {
2595       result = (floatp *)new_floatp();
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2611       };
2612     }
2613   }
2614   jresult = (void *)result;
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2620   floatp *arg1 = (floatp *) 0 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   {
2624     try {
2625       delete_floatp(arg1);
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2633       };
2634     } catch (Dali::DaliException e) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2641       };
2642     }
2643   }
2644
2645 }
2646
2647
2648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2649   floatp *arg1 = (floatp *) 0 ;
2650   float arg2 ;
2651
2652   arg1 = (floatp *)jarg1;
2653   arg2 = (float)jarg2;
2654   {
2655     try {
2656       floatp_assign(arg1,arg2);
2657     } catch (std::out_of_range& e) {
2658       {
2659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (std::exception& e) {
2662       {
2663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2664       };
2665     } catch (Dali::DaliException e) {
2666       {
2667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2668       };
2669     } catch (...) {
2670       {
2671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2672       };
2673     }
2674   }
2675
2676 }
2677
2678
2679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2680   float jresult ;
2681   floatp *arg1 = (floatp *) 0 ;
2682   float result;
2683
2684   arg1 = (floatp *)jarg1;
2685   {
2686     try {
2687       result = (float)floatp_value(arg1);
2688     } catch (std::out_of_range& e) {
2689       {
2690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (std::exception& e) {
2693       {
2694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2695       };
2696     } catch (DaliException e) {
2697       {
2698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2699       };
2700     } catch (...) {
2701       {
2702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2703       };
2704     }
2705   }
2706   jresult = result;
2707   return jresult;
2708 }
2709
2710
2711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2712   void * jresult ;
2713   floatp *arg1 = (floatp *) 0 ;
2714   float *result = 0 ;
2715
2716   arg1 = (floatp *)jarg1;
2717   {
2718     try {
2719       result = (float *)floatp_cast(arg1);
2720     } catch (std::out_of_range& e) {
2721       {
2722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2723       };
2724     } catch (std::exception& e) {
2725       {
2726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2727       };
2728     } catch (Dali::DaliException e) {
2729       {
2730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2731       };
2732     } catch (...) {
2733       {
2734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2735       };
2736     }
2737   }
2738
2739   jresult = (void *)result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2745   void * jresult ;
2746   float *arg1 = (float *) 0 ;
2747   floatp *result = 0 ;
2748
2749   arg1 = (float *)jarg1;
2750   {
2751     try {
2752       result = (floatp *)floatp_frompointer(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2760       };
2761     } catch (Dali::DaliException e) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2764       };
2765     } catch (...) {
2766       {
2767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2768       };
2769     }
2770   }
2771
2772   jresult = (void *)result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2778   void * jresult ;
2779   intp *result = 0 ;
2780
2781   {
2782     try {
2783       result = (intp *)new_intp();
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (Dali::DaliException e) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802
2803   jresult = (void *)result;
2804   return jresult;
2805 }
2806
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2809   intp *arg1 = (intp *) 0 ;
2810
2811   arg1 = (intp *)jarg1;
2812   {
2813     try {
2814       delete_intp(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2822       };
2823     } catch (Dali::DaliException e) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2826       };
2827     } catch (...) {
2828       {
2829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2830       };
2831     }
2832   }
2833
2834 }
2835
2836
2837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2838   intp *arg1 = (intp *) 0 ;
2839   int arg2 ;
2840
2841   arg1 = (intp *)jarg1;
2842   arg2 = (int)jarg2;
2843   {
2844     try {
2845       intp_assign(arg1,arg2);
2846     } catch (std::out_of_range& e) {
2847       {
2848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (std::exception& e) {
2851       {
2852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2853       };
2854     } catch (Dali::DaliException e) {
2855       {
2856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2857       };
2858     } catch (...) {
2859       {
2860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2861       };
2862     }
2863   }
2864
2865 }
2866
2867
2868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2869   int jresult ;
2870   intp *arg1 = (intp *) 0 ;
2871   int result;
2872
2873   arg1 = (intp *)jarg1;
2874   {
2875     try {
2876       result = (int)intp_value(arg1);
2877     } catch (std::out_of_range& e) {
2878       {
2879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2880       };
2881     } catch (std::exception& e) {
2882       {
2883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2884       };
2885     } catch (Dali::DaliException e) {
2886       {
2887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2892       };
2893     }
2894   }
2895
2896   jresult = result;
2897   return jresult;
2898 }
2899
2900
2901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2902   void * jresult ;
2903   intp *arg1 = (intp *) 0 ;
2904   int *result = 0 ;
2905
2906   arg1 = (intp *)jarg1;
2907   {
2908     try {
2909       result = (int *)intp_cast(arg1);
2910     } catch (std::out_of_range& e) {
2911       {
2912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (std::exception& e) {
2915       {
2916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2917       };
2918     } catch (Dali::DaliException e) {
2919       {
2920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2925       };
2926     }
2927   }
2928
2929   jresult = (void *)result;
2930   return jresult;
2931 }
2932
2933
2934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2935   void * jresult ;
2936   int *arg1 = (int *) 0 ;
2937   intp *result = 0 ;
2938
2939   arg1 = (int *)jarg1;
2940   {
2941     try {
2942       result = (intp *)intp_frompointer(arg1);
2943     } catch (std::out_of_range& e) {
2944       {
2945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2946       };
2947     } catch (std::exception& e) {
2948       {
2949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (Dali::DaliException e) {
2952       {
2953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961
2962   jresult = (void *)result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2968   void * jresult ;
2969   doublep *result = 0 ;
2970
2971   {
2972     try {
2973       result = (doublep *)new_doublep();
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2981       };
2982     } catch (Dali::DaliException e) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2985       };
2986     } catch (...) {
2987       {
2988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2989       };
2990     }
2991   }
2992
2993   jresult = (void *)result;
2994   return jresult;
2995 }
2996
2997
2998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2999   doublep *arg1 = (doublep *) 0 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   {
3003     try {
3004       delete_doublep(arg1);
3005     } catch (std::out_of_range& e) {
3006       {
3007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3008       };
3009     } catch (std::exception& e) {
3010       {
3011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3012       };
3013     } catch (Dali::DaliException e) {
3014       {
3015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3016       };
3017     } catch (...) {
3018       {
3019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3020       };
3021     }
3022   }
3023
3024 }
3025
3026
3027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3028   doublep *arg1 = (doublep *) 0 ;
3029   double arg2 ;
3030
3031   arg1 = (doublep *)jarg1;
3032   arg2 = (double)jarg2;
3033   {
3034     try {
3035       doublep_assign(arg1,arg2);
3036     } catch (std::out_of_range& e) {
3037       {
3038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3039       };
3040     } catch (std::exception& e) {
3041       {
3042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3043       };
3044     } catch (Dali::DaliException e) {
3045       {
3046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3047       };
3048     } catch (...) {
3049       {
3050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3051       };
3052     }
3053   }
3054
3055 }
3056
3057
3058 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3059   double jresult ;
3060   doublep *arg1 = (doublep *) 0 ;
3061   double result;
3062
3063   arg1 = (doublep *)jarg1;
3064   {
3065     try {
3066       result = (double)doublep_value(arg1);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3074       };
3075     } catch (Dali::DaliException e) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3078       };
3079     } catch (...) {
3080       {
3081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3082       };
3083     }
3084   }
3085
3086   jresult = result;
3087   return jresult;
3088 }
3089
3090
3091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3092   void * jresult ;
3093   doublep *arg1 = (doublep *) 0 ;
3094   double *result = 0 ;
3095
3096   arg1 = (doublep *)jarg1;
3097   {
3098     try {
3099       result = (double *)doublep_cast(arg1);
3100     } catch (std::out_of_range& e) {
3101       {
3102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3103       };
3104     } catch (std::exception& e) {
3105       {
3106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (Dali::DaliException e) {
3109       {
3110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118
3119   jresult = (void *)result;
3120   return jresult;
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3125   void * jresult ;
3126   double *arg1 = (double *) 0 ;
3127   doublep *result = 0 ;
3128
3129   arg1 = (double *)jarg1;
3130   {
3131     try {
3132       result = (doublep *)doublep_frompointer(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3140       };
3141     } catch (Dali::DaliException e) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3144       };
3145     } catch (...) {
3146       {
3147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3148       };
3149     }
3150   }
3151
3152   jresult = (void *)result;
3153   return jresult;
3154 }
3155
3156
3157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3158   void * jresult ;
3159   uintp *result = 0 ;
3160
3161   {
3162     try {
3163       result = (uintp *)new_uintp();
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (Dali::DaliException e) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3175       };
3176     } catch (...) {
3177       {
3178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3179       };
3180     }
3181   }
3182
3183   jresult = (void *)result;
3184   return jresult;
3185 }
3186
3187
3188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3189   uintp *arg1 = (uintp *) 0 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   {
3193     try {
3194       delete_uintp(arg1);
3195     } catch (std::out_of_range& e) {
3196       {
3197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3198       };
3199     } catch (std::exception& e) {
3200       {
3201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3202       };
3203     } catch (Dali::DaliException e) {
3204       {
3205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3206       };
3207     } catch (...) {
3208       {
3209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3210       };
3211     }
3212   }
3213
3214 }
3215
3216
3217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3218   uintp *arg1 = (uintp *) 0 ;
3219   unsigned int arg2 ;
3220
3221   arg1 = (uintp *)jarg1;
3222   arg2 = (unsigned int)jarg2;
3223   {
3224     try {
3225       uintp_assign(arg1,arg2);
3226     } catch (std::out_of_range& e) {
3227       {
3228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3229       };
3230     } catch (std::exception& e) {
3231       {
3232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3233       };
3234     } catch (Dali::DaliException e) {
3235       {
3236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3237       };
3238     } catch (...) {
3239       {
3240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3241       };
3242     }
3243   }
3244
3245 }
3246
3247
3248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3249   unsigned int jresult ;
3250   uintp *arg1 = (uintp *) 0 ;
3251   unsigned int result;
3252
3253   arg1 = (uintp *)jarg1;
3254   {
3255     try {
3256       result = (unsigned int)uintp_value(arg1);
3257     } catch (std::out_of_range& e) {
3258       {
3259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (std::exception& e) {
3262       {
3263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3264       };
3265     } catch (Dali::DaliException e) {
3266       {
3267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3268       };
3269     } catch (...) {
3270       {
3271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3272       };
3273     }
3274   }
3275
3276   jresult = result;
3277   return jresult;
3278 }
3279
3280
3281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3282   void * jresult ;
3283   uintp *arg1 = (uintp *) 0 ;
3284   unsigned int *result = 0 ;
3285
3286   arg1 = (uintp *)jarg1;
3287   {
3288     try {
3289       result = (unsigned int *)uintp_cast(arg1);
3290     } catch (std::out_of_range& e) {
3291       {
3292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (std::exception& e) {
3295       {
3296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (Dali::DaliException e) {
3299       {
3300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308
3309   jresult = (void *)result;
3310   return jresult;
3311 }
3312
3313
3314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3315   void * jresult ;
3316   unsigned int *arg1 = (unsigned int *) 0 ;
3317   uintp *result = 0 ;
3318
3319   arg1 = (unsigned int *)jarg1;
3320   {
3321     try {
3322       result = (uintp *)uintp_frompointer(arg1);
3323     } catch (std::out_of_range& e) {
3324       {
3325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3326       };
3327     } catch (std::exception& e) {
3328       {
3329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3330       };
3331     } catch (Dali::DaliException e) {
3332       {
3333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3334       };
3335     } catch (...) {
3336       {
3337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3338       };
3339     }
3340   }
3341
3342   jresult = (void *)result;
3343   return jresult;
3344 }
3345
3346
3347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3348   void * jresult ;
3349   ushortp *result = 0 ;
3350
3351   {
3352     try {
3353       result = (ushortp *)new_ushortp();
3354     } catch (std::out_of_range& e) {
3355       {
3356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3357       };
3358     } catch (std::exception& e) {
3359       {
3360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3361       };
3362     } catch (Dali::DaliException e) {
3363       {
3364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3365       };
3366     } catch (...) {
3367       {
3368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3369       };
3370     }
3371   }
3372
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3379   ushortp *arg1 = (ushortp *) 0 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   {
3383     try {
3384       delete_ushortp(arg1);
3385     } catch (std::out_of_range& e) {
3386       {
3387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3388       };
3389     } catch (std::exception& e) {
3390       {
3391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3392       };
3393     } catch (Dali::DaliException e) {
3394       {
3395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3396       };
3397     } catch (...) {
3398       {
3399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3400       };
3401     }
3402   }
3403
3404 }
3405
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3408   ushortp *arg1 = (ushortp *) 0 ;
3409   unsigned short arg2 ;
3410
3411   arg1 = (ushortp *)jarg1;
3412   arg2 = (unsigned short)jarg2;
3413   {
3414     try {
3415       ushortp_assign(arg1,arg2);
3416     } catch (std::out_of_range& e) {
3417       {
3418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3419       };
3420     } catch (std::exception& e) {
3421       {
3422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (Dali::DaliException e) {
3425       {
3426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434
3435 }
3436
3437
3438 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3439   unsigned short jresult ;
3440   ushortp *arg1 = (ushortp *) 0 ;
3441   unsigned short result;
3442
3443   arg1 = (ushortp *)jarg1;
3444   {
3445     try {
3446       result = (unsigned short)ushortp_value(arg1);
3447     } catch (std::out_of_range& e) {
3448       {
3449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3450       };
3451     } catch (std::exception& e) {
3452       {
3453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (Dali::DaliException e) {
3456       {
3457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465
3466   jresult = result;
3467   return jresult;
3468 }
3469
3470
3471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3472   void * jresult ;
3473   ushortp *arg1 = (ushortp *) 0 ;
3474   unsigned short *result = 0 ;
3475
3476   arg1 = (ushortp *)jarg1;
3477   {
3478     try {
3479       result = (unsigned short *)ushortp_cast(arg1);
3480     } catch (std::out_of_range& e) {
3481       {
3482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3483       };
3484     } catch (std::exception& e) {
3485       {
3486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (Dali::DaliException e) {
3489       {
3490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3491       };
3492     } catch (...) {
3493       {
3494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3495       };
3496     }
3497   }
3498
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3505   void * jresult ;
3506   unsigned short *arg1 = (unsigned short *) 0 ;
3507   ushortp *result = 0 ;
3508
3509   arg1 = (unsigned short *)jarg1;
3510   {
3511     try {
3512       result = (ushortp *)ushortp_frompointer(arg1);
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (Dali::DaliException e) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3538   unsigned int jresult ;
3539   int arg1 ;
3540   unsigned int result;
3541
3542   arg1 = (int)jarg1;
3543   {
3544     try {
3545       result = (unsigned int)int_to_uint(arg1);
3546     } catch (std::out_of_range& e) {
3547       {
3548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3549       };
3550     } catch (std::exception& e) {
3551       {
3552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3553       };
3554     } catch (Dali::DaliException e) {
3555       {
3556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3557       };
3558     } catch (...) {
3559       {
3560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3561       };
3562     }
3563   }
3564
3565   jresult = result;
3566   return jresult;
3567 }
3568
3569
3570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3571   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3572
3573   arg1 = (Dali::RefObject *)jarg1;
3574   {
3575     try {
3576       (arg1)->Reference();
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3584       };
3585     } catch (Dali::DaliException e) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3588       };
3589     } catch (...) {
3590       {
3591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3592       };
3593     }
3594   }
3595
3596 }
3597
3598
3599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601
3602   arg1 = (Dali::RefObject *)jarg1;
3603   {
3604     try {
3605       (arg1)->Unreference();
3606     } catch (std::out_of_range& e) {
3607       {
3608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3609       };
3610     } catch (std::exception& e) {
3611       {
3612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (Dali::DaliException e) {
3615       {
3616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624
3625 }
3626
3627
3628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3629   int jresult ;
3630   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3631   int result;
3632
3633   arg1 = (Dali::RefObject *)jarg1;
3634   {
3635     try {
3636       result = (int)(arg1)->ReferenceCount();
3637     } catch (std::out_of_range& e) {
3638       {
3639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3640       };
3641     } catch (std::exception& e) {
3642       {
3643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3644       };
3645     } catch (Dali::DaliException e) {
3646       {
3647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3648       };
3649     } catch (...) {
3650       {
3651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3652       };
3653     }
3654   }
3655
3656   jresult = result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3662   void * jresult ;
3663   Dali::Any *result = 0 ;
3664
3665   {
3666     try {
3667       result = (Dali::Any *)new Dali::Any();
3668     } catch (std::out_of_range& e) {
3669       {
3670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3671       };
3672     } catch (std::exception& e) {
3673       {
3674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3675       };
3676     } catch (Dali::DaliException e) {
3677       {
3678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3679       };
3680     } catch (...) {
3681       {
3682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3683       };
3684     }
3685   }
3686
3687   jresult = (void *)result;
3688   return jresult;
3689 }
3690
3691
3692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3693   Dali::Any *arg1 = (Dali::Any *) 0 ;
3694
3695   arg1 = (Dali::Any *)jarg1;
3696   {
3697     try {
3698       delete arg1;
3699     } catch (std::out_of_range& e) {
3700       {
3701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3702       };
3703     } catch (std::exception& e) {
3704       {
3705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3706       };
3707     } catch (Dali::DaliException e) {
3708       {
3709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3714       };
3715     }
3716   }
3717
3718 }
3719
3720
3721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3722   char *arg1 = (char *) 0 ;
3723
3724   arg1 = (char *)jarg1;
3725   {
3726     try {
3727       Dali::Any::AssertAlways((char const *)arg1);
3728     } catch (std::out_of_range& e) {
3729       {
3730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3731       };
3732     } catch (std::exception& e) {
3733       {
3734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3735       };
3736     } catch (Dali::DaliException e) {
3737       {
3738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3739       };
3740     } catch (...) {
3741       {
3742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3743       };
3744     }
3745   }
3746
3747 }
3748
3749
3750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3751   void * jresult ;
3752   Dali::Any *arg1 = 0 ;
3753   Dali::Any *result = 0 ;
3754
3755   arg1 = (Dali::Any *)jarg1;
3756   if (!arg1) {
3757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3758     return 0;
3759   }
3760   {
3761     try {
3762       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (Dali::DaliException e) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3774       };
3775     } catch (...) {
3776       {
3777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3778       };
3779     }
3780   }
3781
3782   jresult = (void *)result;
3783   return jresult;
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3788   void * jresult ;
3789   Dali::Any *arg1 = (Dali::Any *) 0 ;
3790   Dali::Any *arg2 = 0 ;
3791   Dali::Any *result = 0 ;
3792
3793   arg1 = (Dali::Any *)jarg1;
3794   arg2 = (Dali::Any *)jarg2;
3795   if (!arg2) {
3796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3797     return 0;
3798   }
3799   {
3800     try {
3801       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3802     } catch (std::out_of_range& e) {
3803       {
3804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3805       };
3806     } catch (std::exception& e) {
3807       {
3808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3809       };
3810     } catch (Dali::DaliException e) {
3811       {
3812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3813       };
3814     } catch (...) {
3815       {
3816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3817       };
3818     }
3819   }
3820
3821   jresult = (void *)result;
3822   return jresult;
3823 }
3824
3825
3826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3827   void * jresult ;
3828   Dali::Any *arg1 = (Dali::Any *) 0 ;
3829   std::type_info *result = 0 ;
3830
3831   arg1 = (Dali::Any *)jarg1;
3832   {
3833     try {
3834       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3835     } catch (std::out_of_range& e) {
3836       {
3837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3838       };
3839     } catch (std::exception& e) {
3840       {
3841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3842       };
3843     } catch (Dali::DaliException e) {
3844       {
3845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3846       };
3847     } catch (...) {
3848       {
3849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3850       };
3851     }
3852   }
3853
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3860   unsigned int jresult ;
3861   Dali::Any *arg1 = (Dali::Any *) 0 ;
3862   bool result;
3863
3864   arg1 = (Dali::Any *)jarg1;
3865   {
3866     try {
3867       result = (bool)((Dali::Any const *)arg1)->Empty();
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3875       };
3876     } catch (Dali::DaliException e) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3879       };
3880     } catch (...) {
3881       {
3882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3883       };
3884     }
3885   }
3886
3887   jresult = result;
3888   return jresult;
3889 }
3890
3891
3892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3893   void * jresult ;
3894   std::type_info *arg1 = 0 ;
3895   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3896   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3897   Dali::Any::AnyContainerBase *result = 0 ;
3898
3899   arg1 = (std::type_info *)jarg1;
3900   if (!arg1) {
3901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3902     return 0;
3903   }
3904   arg2 = (Dali::Any::CloneFunc)jarg2;
3905   arg3 = (Dali::Any::DeleteFunc)jarg3;
3906   {
3907     try {
3908       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3909     } catch (std::out_of_range& e) {
3910       {
3911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3912       };
3913     } catch (std::exception& e) {
3914       {
3915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3916       };
3917     } catch (Dali::DaliException e) {
3918       {
3919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3920       };
3921     } catch (...) {
3922       {
3923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3924       };
3925     }
3926   }
3927
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3934   void * jresult ;
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   std::type_info *result = 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   {
3940     try {
3941       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3942     } catch (std::out_of_range& e) {
3943       {
3944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3945       };
3946     } catch (std::exception& e) {
3947       {
3948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3949       };
3950     } catch (Dali::DaliException e) {
3951       {
3952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3953       };
3954     } catch (...) {
3955       {
3956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3957       };
3958     }
3959   }
3960
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   ::std::type_info *result = 0 ;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3981
3982   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3983   arg2 = (Dali::Any::CloneFunc)jarg2;
3984   if (arg1) (arg1)->mCloneFunc = arg2;
3985 }
3986
3987
3988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3989   void * jresult ;
3990   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3991   Dali::Any::CloneFunc result;
3992
3993   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3994   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3995   jresult = (void *)result;
3996   return jresult;
3997 }
3998
3999
4000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4001   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4002   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4003
4004   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4005   arg2 = (Dali::Any::DeleteFunc)jarg2;
4006   if (arg1) (arg1)->mDeleteFunc = arg2;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4011   void * jresult ;
4012   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4013   Dali::Any::DeleteFunc result;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4017   jresult = (void *)result;
4018   return jresult;
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4023   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4026   {
4027     try {
4028       delete arg1;
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4036       };
4037     } catch (Dali::DaliException e) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4040       };
4041     } catch (...) {
4042       {
4043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4044       };
4045     }
4046   }
4047
4048 }
4049
4050
4051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4052   Dali::Any *arg1 = (Dali::Any *) 0 ;
4053   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4054
4055   arg1 = (Dali::Any *)jarg1;
4056   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4057   if (arg1) (arg1)->mContainer = arg2;
4058 }
4059
4060
4061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4062   void * jresult ;
4063   Dali::Any *arg1 = (Dali::Any *) 0 ;
4064   Dali::Any::AnyContainerBase *result = 0 ;
4065
4066   arg1 = (Dali::Any *)jarg1;
4067   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4068   jresult = (void *)result;
4069   return jresult;
4070 }
4071
4072
4073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4074   char *arg1 = (char *) 0 ;
4075   char *arg2 = (char *) 0 ;
4076
4077   arg1 = (char *)jarg1;
4078   arg2 = (char *)jarg2;
4079   {
4080     try {
4081       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4082     } catch (std::out_of_range& e) {
4083       {
4084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4085       };
4086     } catch (std::exception& e) {
4087       {
4088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4089       };
4090     } catch (Dali::DaliException e) {
4091       {
4092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4093       };
4094     } catch (...) {
4095       {
4096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4097       };
4098     }
4099   }
4100
4101 }
4102
4103
4104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4105   void * jresult ;
4106   char *arg1 = (char *) 0 ;
4107   char *arg2 = (char *) 0 ;
4108   Dali::DaliException *result = 0 ;
4109
4110   arg1 = (char *)jarg1;
4111   arg2 = (char *)jarg2;
4112   {
4113     try {
4114       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4115     } catch (std::out_of_range& e) {
4116       {
4117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (std::exception& e) {
4120       {
4121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4122       };
4123     } catch (Dali::DaliException e) {
4124       {
4125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4126       };
4127     } catch (...) {
4128       {
4129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4130       };
4131     }
4132   }
4133
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4140   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4141   std::string arg2 = std::string(jarg2);
4142
4143   arg1 = (Dali::DaliException *)jarg1;
4144   {
4145     if (!arg2.empty()) {
4146       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4147     } else {
4148       arg1->location = 0;
4149     }
4150   }
4151 }
4152
4153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4154   char * jresult ;
4155   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4156   char *result = 0 ;
4157
4158   arg1 = (Dali::DaliException *)jarg1;
4159   result = (char *) ((arg1)->location);
4160   jresult = SWIG_csharp_string_callback((const char *)result);
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4166   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4167   std::string arg2 = std::string(jarg2);
4168
4169   arg1 = (Dali::DaliException *)jarg1;
4170   {
4171     if (!arg2.empty()) {
4172       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4173     } else {
4174       arg1->condition = 0;
4175     }
4176   }
4177 }
4178
4179
4180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4181   char * jresult ;
4182   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4183   char *result = 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   result = (char *) ((arg1)->condition);
4187   jresult = SWIG_csharp_string_callback((const char *)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4193   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4194
4195   arg1 = (Dali::DaliException *)jarg1;
4196   {
4197     try {
4198       delete arg1;
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4206       };
4207     } catch (Dali::DaliException e) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4210       };
4211     } catch (...) {
4212       {
4213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4214       };
4215     }
4216   }
4217
4218 }
4219
4220
4221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4222   void * jresult ;
4223   Dali::Vector2 *result = 0 ;
4224
4225   {
4226     try {
4227       result = (Dali::Vector2 *)new Dali::Vector2();
4228     } catch (std::out_of_range& e) {
4229       {
4230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4231       };
4232     } catch (std::exception& e) {
4233       {
4234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (Dali::DaliException e) {
4237       {
4238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246
4247   jresult = (void *)result;
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4253   void * jresult ;
4254   float arg1 ;
4255   float arg2 ;
4256   Dali::Vector2 *result = 0 ;
4257
4258   arg1 = (float)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (Dali::DaliException e) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4274       };
4275     } catch (...) {
4276       {
4277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4278       };
4279     }
4280   }
4281
4282   jresult = (void *)result;
4283   return jresult;
4284 }
4285
4286
4287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4288   void * jresult ;
4289   float *arg1 = (float *) 0 ;
4290   Dali::Vector2 *result = 0 ;
4291
4292   arg1 = jarg1;
4293   {
4294     try {
4295       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4296     } catch (std::out_of_range& e) {
4297       {
4298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4299       };
4300     } catch (std::exception& e) {
4301       {
4302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4303       };
4304     } catch (Dali::DaliException e) {
4305       {
4306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4307       };
4308     } catch (...) {
4309       {
4310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4311       };
4312     }
4313   }
4314
4315   jresult = (void *)result;
4316
4317
4318   return jresult;
4319 }
4320
4321
4322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4323   void * jresult ;
4324   Dali::Vector3 *arg1 = 0 ;
4325   Dali::Vector2 *result = 0 ;
4326
4327   arg1 = (Dali::Vector3 *)jarg1;
4328   if (!arg1) {
4329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4330     return 0;
4331   }
4332   {
4333     try {
4334       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4335     } catch (std::out_of_range& e) {
4336       {
4337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4338       };
4339     } catch (std::exception& e) {
4340       {
4341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4342       };
4343     } catch (Dali::DaliException e) {
4344       {
4345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4346       };
4347     } catch (...) {
4348       {
4349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4350       };
4351     }
4352   }
4353
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4360   void * jresult ;
4361   Dali::Vector4 *arg1 = 0 ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   arg1 = (Dali::Vector4 *)jarg1;
4365   if (!arg1) {
4366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4367     return 0;
4368   }
4369   {
4370     try {
4371       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4372     } catch (std::out_of_range& e) {
4373       {
4374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4375       };
4376     } catch (std::exception& e) {
4377       {
4378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (Dali::DaliException e) {
4381       {
4382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4447   void * jresult ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4451   jresult = (void *)result;
4452   return jresult;
4453 }
4454
4455
4456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4457   void * jresult ;
4458   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4459   float *arg2 = (float *) 0 ;
4460   Dali::Vector2 *result = 0 ;
4461
4462   arg1 = (Dali::Vector2 *)jarg1;
4463   arg2 = jarg2;
4464   {
4465     try {
4466       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4467     } catch (std::out_of_range& e) {
4468       {
4469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (std::exception& e) {
4472       {
4473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4474       };
4475     } catch (Dali::DaliException e) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4478       };
4479     } catch (...) {
4480       {
4481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4482       };
4483     }
4484   }
4485
4486   jresult = (void *)result;
4487
4488
4489   return jresult;
4490 }
4491
4492
4493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4494   void * jresult ;
4495   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4496   Dali::Vector3 *arg2 = 0 ;
4497   Dali::Vector2 *result = 0 ;
4498
4499   arg1 = (Dali::Vector2 *)jarg1;
4500   arg2 = (Dali::Vector3 *)jarg2;
4501   if (!arg2) {
4502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4503     return 0;
4504   }
4505   {
4506     try {
4507       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4508     } catch (std::out_of_range& e) {
4509       {
4510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4511       };
4512     } catch (std::exception& e) {
4513       {
4514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4515       };
4516     } catch (Dali::DaliException e) {
4517       {
4518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4519       };
4520     } catch (...) {
4521       {
4522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4523       };
4524     }
4525   }
4526
4527   jresult = (void *)result;
4528   return jresult;
4529 }
4530
4531
4532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4533   void * jresult ;
4534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4535   Dali::Vector4 *arg2 = 0 ;
4536   Dali::Vector2 *result = 0 ;
4537
4538   arg1 = (Dali::Vector2 *)jarg1;
4539   arg2 = (Dali::Vector4 *)jarg2;
4540   if (!arg2) {
4541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4542     return 0;
4543   }
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (Dali::DaliException e) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565
4566   jresult = (void *)result;
4567   return jresult;
4568 }
4569
4570
4571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4572   void * jresult ;
4573   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4574   Dali::Vector2 *arg2 = 0 ;
4575   Dali::Vector2 result;
4576
4577   arg1 = (Dali::Vector2 *)jarg1;
4578   arg2 = (Dali::Vector2 *)jarg2;
4579   if (!arg2) {
4580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4581     return 0;
4582   }
4583   {
4584     try {
4585       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4586     } catch (std::out_of_range& e) {
4587       {
4588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (std::exception& e) {
4591       {
4592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4593       };
4594     } catch (Dali::DaliException e) {
4595       {
4596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4597       };
4598     } catch (...) {
4599       {
4600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4601       };
4602     }
4603   }
4604
4605   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4606   return jresult;
4607 }
4608
4609
4610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4611   void * jresult ;
4612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4613   Dali::Vector2 *arg2 = 0 ;
4614   Dali::Vector2 *result = 0 ;
4615
4616   arg1 = (Dali::Vector2 *)jarg1;
4617   arg2 = (Dali::Vector2 *)jarg2;
4618   if (!arg2) {
4619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4620     return 0;
4621   }
4622   {
4623     try {
4624       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4625     } catch (std::out_of_range& e) {
4626       {
4627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4628       };
4629     } catch (std::exception& e) {
4630       {
4631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4632       };
4633     } catch (Dali::DaliException e) {
4634       {
4635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4636       };
4637     } catch (...) {
4638       {
4639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4640       };
4641     }
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4650   void * jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   Dali::Vector2 *arg2 = 0 ;
4653   Dali::Vector2 result;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   arg2 = (Dali::Vector2 *)jarg2;
4657   if (!arg2) {
4658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4659     return 0;
4660   }
4661   {
4662     try {
4663       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4664     } catch (std::out_of_range& e) {
4665       {
4666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4667       };
4668     } catch (std::exception& e) {
4669       {
4670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (Dali::DaliException e) {
4673       {
4674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4675       };
4676     } catch (...) {
4677       {
4678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4679       };
4680     }
4681   }
4682
4683   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4689   void * jresult ;
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691   Dali::Vector2 *arg2 = 0 ;
4692   Dali::Vector2 *result = 0 ;
4693
4694   arg1 = (Dali::Vector2 *)jarg1;
4695   arg2 = (Dali::Vector2 *)jarg2;
4696   if (!arg2) {
4697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4698     return 0;
4699   }
4700   {
4701     try {
4702       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4703     } catch (std::out_of_range& e) {
4704       {
4705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4706       };
4707     } catch (std::exception& e) {
4708       {
4709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4710       };
4711     } catch (Dali::DaliException e) {
4712       {
4713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4714       };
4715     } catch (...) {
4716       {
4717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4718       };
4719     }
4720   }
4721
4722   jresult = (void *)result;
4723   return jresult;
4724 }
4725
4726
4727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4728   void * jresult ;
4729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4730   Dali::Vector2 *arg2 = 0 ;
4731   Dali::Vector2 result;
4732
4733   arg1 = (Dali::Vector2 *)jarg1;
4734   arg2 = (Dali::Vector2 *)jarg2;
4735   if (!arg2) {
4736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4737     return 0;
4738   }
4739   {
4740     try {
4741       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4742     } catch (std::out_of_range& e) {
4743       {
4744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4745       };
4746     } catch (std::exception& e) {
4747       {
4748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4749       };
4750     } catch (Dali::DaliException e) {
4751       {
4752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4753       };
4754     } catch (...) {
4755       {
4756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4757       };
4758     }
4759   }
4760
4761   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4767   void * jresult ;
4768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4769   float arg2 ;
4770   Dali::Vector2 result;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   arg2 = (float)jarg2;
4774   {
4775     try {
4776       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4777     } catch (std::out_of_range& e) {
4778       {
4779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4780       };
4781     } catch (std::exception& e) {
4782       {
4783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4784       };
4785     } catch (Dali::DaliException e) {
4786       {
4787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4788       };
4789     } catch (...) {
4790       {
4791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4792       };
4793     }
4794   }
4795
4796   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4797   return jresult;
4798 }
4799
4800
4801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4802   void * jresult ;
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   Dali::Vector2 *arg2 = 0 ;
4805   Dali::Vector2 *result = 0 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (Dali::Vector2 *)jarg2;
4809   if (!arg2) {
4810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4811     return 0;
4812   }
4813   {
4814     try {
4815       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4816     } catch (std::out_of_range& e) {
4817       {
4818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4819       };
4820     } catch (std::exception& e) {
4821       {
4822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (Dali::DaliException e) {
4825       {
4826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834
4835   jresult = (void *)result;
4836   return jresult;
4837 }
4838
4839
4840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4841   void * jresult ;
4842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4843   float arg2 ;
4844   Dali::Vector2 *result = 0 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   {
4849     try {
4850       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4851     } catch (std::out_of_range& e) {
4852       {
4853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4854       };
4855     } catch (std::exception& e) {
4856       {
4857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4858       };
4859     } catch (Dali::DaliException e) {
4860       {
4861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4862       };
4863     } catch (...) {
4864       {
4865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4866       };
4867     }
4868   }
4869
4870   jresult = (void *)result;
4871   return jresult;
4872 }
4873
4874
4875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4876   void * jresult ;
4877   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4878   Dali::Vector2 *arg2 = 0 ;
4879   Dali::Vector2 result;
4880
4881   arg1 = (Dali::Vector2 *)jarg1;
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (Dali::DaliException e) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4901       };
4902     } catch (...) {
4903       {
4904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4905       };
4906     }
4907   }
4908
4909   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4910   return jresult;
4911 }
4912
4913
4914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4915   void * jresult ;
4916   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4917   float arg2 ;
4918   Dali::Vector2 result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   arg2 = (float)jarg2;
4922   {
4923     try {
4924       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4925     } catch (std::out_of_range& e) {
4926       {
4927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4928       };
4929     } catch (std::exception& e) {
4930       {
4931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4932       };
4933     } catch (Dali::DaliException e) {
4934       {
4935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4936       };
4937     } catch (...) {
4938       {
4939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4940       };
4941     }
4942   }
4943
4944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4950   void * jresult ;
4951   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4952   Dali::Vector2 *arg2 = 0 ;
4953   Dali::Vector2 *result = 0 ;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   arg2 = (Dali::Vector2 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   {
4962     try {
4963       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4964     } catch (std::out_of_range& e) {
4965       {
4966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4967       };
4968     } catch (std::exception& e) {
4969       {
4970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (Dali::DaliException e) {
4973       {
4974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982
4983   jresult = (void *)result;
4984   return jresult;
4985 }
4986
4987
4988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4989   void * jresult ;
4990   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4991   float arg2 ;
4992   Dali::Vector2 *result = 0 ;
4993
4994   arg1 = (Dali::Vector2 *)jarg1;
4995   arg2 = (float)jarg2;
4996   {
4997     try {
4998       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4999     } catch (std::out_of_range& e) {
5000       {
5001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5002       };
5003     } catch (std::exception& e) {
5004       {
5005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5006       };
5007     } catch (Dali::DaliException e) {
5008       {
5009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5010       };
5011     } catch (...) {
5012       {
5013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5014       };
5015     }
5016   }
5017
5018   jresult = (void *)result;
5019   return jresult;
5020 }
5021
5022
5023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5024   void * jresult ;
5025   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5026   Dali::Vector2 result;
5027
5028   arg1 = (Dali::Vector2 *)jarg1;
5029   {
5030     try {
5031       result = ((Dali::Vector2 const *)arg1)->operator -();
5032     } catch (std::out_of_range& e) {
5033       {
5034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (std::exception& e) {
5037       {
5038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5039       };
5040     } catch (Dali::DaliException e) {
5041       {
5042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5043       };
5044     } catch (...) {
5045       {
5046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5047       };
5048     }
5049   }
5050
5051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5052   return jresult;
5053 }
5054
5055
5056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5057   unsigned int jresult ;
5058   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5059   Dali::Vector2 *arg2 = 0 ;
5060   bool result;
5061
5062   arg1 = (Dali::Vector2 *)jarg1;
5063   arg2 = (Dali::Vector2 *)jarg2;
5064   if (!arg2) {
5065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5066     return 0;
5067   }
5068   {
5069     try {
5070       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (Dali::DaliException e) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5082       };
5083     } catch (...) {
5084       {
5085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5086       };
5087     }
5088   }
5089
5090   jresult = result;
5091   return jresult;
5092 }
5093
5094
5095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5096   unsigned int jresult ;
5097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5098   Dali::Vector2 *arg2 = 0 ;
5099   bool result;
5100
5101   arg1 = (Dali::Vector2 *)jarg1;
5102   arg2 = (Dali::Vector2 *)jarg2;
5103   if (!arg2) {
5104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5105     return 0;
5106   }
5107   {
5108     try {
5109       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5110     } catch (std::out_of_range& e) {
5111       {
5112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (std::exception& e) {
5115       {
5116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5117       };
5118     } catch (Dali::DaliException e) {
5119       {
5120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5121       };
5122     } catch (...) {
5123       {
5124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5125       };
5126     }
5127   }
5128
5129   jresult = result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5135   float jresult ;
5136   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5137   unsigned int arg2 ;
5138   float *result = 0 ;
5139
5140   arg1 = (Dali::Vector2 *)jarg1;
5141   arg2 = (unsigned int)jarg2;
5142   {
5143     try {
5144       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5145     } catch (std::out_of_range& e) {
5146       {
5147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5148       };
5149     } catch (std::exception& e) {
5150       {
5151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5152       };
5153     } catch (Dali::DaliException e) {
5154       {
5155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5156       };
5157     } catch (...) {
5158       {
5159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5160       };
5161     }
5162   }
5163
5164   jresult = *result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5170   float jresult ;
5171   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5172   float result;
5173
5174   arg1 = (Dali::Vector2 *)jarg1;
5175   {
5176     try {
5177       result = (float)((Dali::Vector2 const *)arg1)->Length();
5178     } catch (std::out_of_range& e) {
5179       {
5180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5181       };
5182     } catch (std::exception& e) {
5183       {
5184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5185       };
5186     } catch (Dali::DaliException e) {
5187       {
5188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5189       };
5190     } catch (...) {
5191       {
5192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5193       };
5194     }
5195   }
5196
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5203   float jresult ;
5204   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5205   float result;
5206
5207   arg1 = (Dali::Vector2 *)jarg1;
5208   {
5209     try {
5210       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5211     } catch (std::out_of_range& e) {
5212       {
5213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5214       };
5215     } catch (std::exception& e) {
5216       {
5217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (Dali::DaliException e) {
5220       {
5221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229
5230   jresult = result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5236   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5237
5238   arg1 = (Dali::Vector2 *)jarg1;
5239   {
5240     try {
5241       (arg1)->Normalize();
5242     } catch (std::out_of_range& e) {
5243       {
5244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5245       };
5246     } catch (std::exception& e) {
5247       {
5248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5249       };
5250     } catch (Dali::DaliException e) {
5251       {
5252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5253       };
5254     } catch (...) {
5255       {
5256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5257       };
5258     }
5259   }
5260
5261 }
5262
5263
5264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5266   Dali::Vector2 *arg2 = 0 ;
5267   Dali::Vector2 *arg3 = 0 ;
5268
5269   arg1 = (Dali::Vector2 *)jarg1;
5270   arg2 = (Dali::Vector2 *)jarg2;
5271   if (!arg2) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   arg3 = (Dali::Vector2 *)jarg3;
5276   if (!arg3) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return ;
5279   }
5280   {
5281     try {
5282       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5290       };
5291     } catch (Dali::DaliException e) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5294       };
5295     } catch (...) {
5296       {
5297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5298       };
5299     }
5300   }
5301
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5306   void * jresult ;
5307   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5308   float *result = 0 ;
5309
5310   arg1 = (Dali::Vector2 *)jarg1;
5311   {
5312     try {
5313       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5314     } catch (std::out_of_range& e) {
5315       {
5316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (std::exception& e) {
5319       {
5320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5321       };
5322     } catch (Dali::DaliException e) {
5323       {
5324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5325       };
5326     } catch (...) {
5327       {
5328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5329       };
5330     }
5331   }
5332
5333   jresult = (void *)result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->x = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->x);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->width = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->width);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384   float arg2 ;
5385
5386   arg1 = (Dali::Vector2 *)jarg1;
5387   arg2 = (float)jarg2;
5388   if (arg1) (arg1)->y = arg2;
5389 }
5390
5391
5392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5393   float jresult ;
5394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5395   float result;
5396
5397   arg1 = (Dali::Vector2 *)jarg1;
5398   result = (float) ((arg1)->y);
5399   jresult = result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5406   float arg2 ;
5407
5408   arg1 = (Dali::Vector2 *)jarg1;
5409   arg2 = (float)jarg2;
5410   if (arg1) (arg1)->height = arg2;
5411 }
5412
5413
5414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5415   float jresult ;
5416   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5417   float result;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   result = (float) ((arg1)->height);
5421   jresult = result;
5422   return jresult;
5423 }
5424
5425
5426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5428
5429   arg1 = (Dali::Vector2 *)jarg1;
5430   {
5431     try {
5432       delete arg1;
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5440       };
5441     } catch (Dali::DaliException e) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5444       };
5445     } catch (...) {
5446       {
5447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5448       };
5449     }
5450   }
5451
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector2 *arg1 = 0 ;
5458   Dali::Vector2 *arg2 = 0 ;
5459   Dali::Vector2 result;
5460
5461   arg1 = (Dali::Vector2 *)jarg1;
5462   if (!arg1) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   arg2 = (Dali::Vector2 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5474     } catch (std::out_of_range& e) {
5475       {
5476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (std::exception& e) {
5479       {
5480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5481       };
5482     } catch (Dali::DaliException e) {
5483       {
5484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5485       };
5486     } catch (...) {
5487       {
5488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5489       };
5490     }
5491   }
5492
5493   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector2 *arg1 = 0 ;
5501   Dali::Vector2 *arg2 = 0 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   arg2 = (Dali::Vector2 *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (Dali::DaliException e) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5528       };
5529     } catch (...) {
5530       {
5531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5532       };
5533     }
5534   }
5535
5536   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5537   return jresult;
5538 }
5539
5540
5541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5542   void * jresult ;
5543   Dali::Vector2 *arg1 = 0 ;
5544   float *arg2 = 0 ;
5545   float *arg3 = 0 ;
5546   float temp2 ;
5547   float temp3 ;
5548   Dali::Vector2 result;
5549
5550   arg1 = (Dali::Vector2 *)jarg1;
5551   if (!arg1) {
5552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5553     return 0;
5554   }
5555   temp2 = (float)jarg2;
5556   arg2 = &temp2;
5557   temp3 = (float)jarg3;
5558   arg3 = &temp3;
5559   {
5560     try {
5561       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (Dali::DaliException e) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5573       };
5574     } catch (...) {
5575       {
5576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5577       };
5578     }
5579   }
5580
5581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5587   void * jresult ;
5588   Dali::Vector3 *result = 0 ;
5589
5590   {
5591     try {
5592       result = (Dali::Vector3 *)new Dali::Vector3();
5593     } catch (std::out_of_range& e) {
5594       {
5595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5596       };
5597     } catch (std::exception& e) {
5598       {
5599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (Dali::DaliException e) {
5602       {
5603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5618   void * jresult ;
5619   float arg1 ;
5620   float arg2 ;
5621   float arg3 ;
5622   Dali::Vector3 *result = 0 ;
5623
5624   arg1 = (float)jarg1;
5625   arg2 = (float)jarg2;
5626   arg3 = (float)jarg3;
5627   {
5628     try {
5629       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (Dali::DaliException e) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648
5649   jresult = (void *)result;
5650   return jresult;
5651 }
5652
5653
5654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5655   void * jresult ;
5656   float *arg1 = (float *) 0 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = jarg1;
5660   {
5661     try {
5662       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5663     } catch (std::out_of_range& e) {
5664       {
5665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (std::exception& e) {
5668       {
5669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5670       };
5671     } catch (Dali::DaliException e) {
5672       {
5673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5674       };
5675     } catch (...) {
5676       {
5677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5678       };
5679     }
5680   }
5681
5682   jresult = (void *)result;
5683
5684
5685   return jresult;
5686 }
5687
5688
5689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5690   void * jresult ;
5691   Dali::Vector2 *arg1 = 0 ;
5692   Dali::Vector3 *result = 0 ;
5693
5694   arg1 = (Dali::Vector2 *)jarg1;
5695   if (!arg1) {
5696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5697     return 0;
5698   }
5699   {
5700     try {
5701       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5702     } catch (std::out_of_range& e) {
5703       {
5704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (std::exception& e) {
5707       {
5708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5709       };
5710     } catch (Dali::DaliException e) {
5711       {
5712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5713       };
5714     } catch (...) {
5715       {
5716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5717       };
5718     }
5719   }
5720
5721   jresult = (void *)result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5727   void * jresult ;
5728   Dali::Vector4 *arg1 = 0 ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   arg1 = (Dali::Vector4 *)jarg1;
5732   if (!arg1) {
5733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5734     return 0;
5735   }
5736   {
5737     try {
5738       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (Dali::DaliException e) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5834   void * jresult ;
5835   Dali::Vector3 *result = 0 ;
5836
5837   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5838   jresult = (void *)result;
5839   return jresult;
5840 }
5841
5842
5843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5844   void * jresult ;
5845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5846   float *arg2 = (float *) 0 ;
5847   Dali::Vector3 *result = 0 ;
5848
5849   arg1 = (Dali::Vector3 *)jarg1;
5850   arg2 = jarg2;
5851   {
5852     try {
5853       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (Dali::DaliException e) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5865       };
5866     } catch (...) {
5867       {
5868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5869       };
5870     }
5871   }
5872
5873   jresult = (void *)result;
5874
5875
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5881   void * jresult ;
5882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5883   Dali::Vector2 *arg2 = 0 ;
5884   Dali::Vector3 *result = 0 ;
5885
5886   arg1 = (Dali::Vector3 *)jarg1;
5887   arg2 = (Dali::Vector2 *)jarg2;
5888   if (!arg2) {
5889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5890     return 0;
5891   }
5892   {
5893     try {
5894       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5895     } catch (std::out_of_range& e) {
5896       {
5897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5898       };
5899     } catch (std::exception& e) {
5900       {
5901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (Dali::DaliException e) {
5904       {
5905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913
5914   jresult = (void *)result;
5915   return jresult;
5916 }
5917
5918
5919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5920   void * jresult ;
5921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5922   Dali::Vector4 *arg2 = 0 ;
5923   Dali::Vector3 *result = 0 ;
5924
5925   arg1 = (Dali::Vector3 *)jarg1;
5926   arg2 = (Dali::Vector4 *)jarg2;
5927   if (!arg2) {
5928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5929     return 0;
5930   }
5931   {
5932     try {
5933       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5934     } catch (std::out_of_range& e) {
5935       {
5936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5937       };
5938     } catch (std::exception& e) {
5939       {
5940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5941       };
5942     } catch (Dali::DaliException e) {
5943       {
5944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5945       };
5946     } catch (...) {
5947       {
5948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5949       };
5950     }
5951   }
5952
5953   jresult = (void *)result;
5954   return jresult;
5955 }
5956
5957
5958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5959   void * jresult ;
5960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5961   Dali::Vector3 *arg2 = 0 ;
5962   Dali::Vector3 result;
5963
5964   arg1 = (Dali::Vector3 *)jarg1;
5965   arg2 = (Dali::Vector3 *)jarg2;
5966   if (!arg2) {
5967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5968     return 0;
5969   }
5970   {
5971     try {
5972       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5973     } catch (std::out_of_range& e) {
5974       {
5975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5976       };
5977     } catch (std::exception& e) {
5978       {
5979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5980       };
5981     } catch (Dali::DaliException e) {
5982       {
5983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5984       };
5985     } catch (...) {
5986       {
5987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5988       };
5989     }
5990   }
5991
5992   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5993   return jresult;
5994 }
5995
5996
5997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5998   void * jresult ;
5999   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6000   Dali::Vector3 *arg2 = 0 ;
6001   Dali::Vector3 *result = 0 ;
6002
6003   arg1 = (Dali::Vector3 *)jarg1;
6004   arg2 = (Dali::Vector3 *)jarg2;
6005   if (!arg2) {
6006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6007     return 0;
6008   }
6009   {
6010     try {
6011       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6012     } catch (std::out_of_range& e) {
6013       {
6014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6015       };
6016     } catch (std::exception& e) {
6017       {
6018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6019       };
6020     } catch (Dali::DaliException e) {
6021       {
6022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6023       };
6024     } catch (...) {
6025       {
6026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6027       };
6028     }
6029   }
6030
6031   jresult = (void *)result;
6032   return jresult;
6033 }
6034
6035
6036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6037   void * jresult ;
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   Dali::Vector3 *arg2 = 0 ;
6040   Dali::Vector3 result;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   arg2 = (Dali::Vector3 *)jarg2;
6044   if (!arg2) {
6045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6046     return 0;
6047   }
6048   {
6049     try {
6050       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6051     } catch (std::out_of_range& e) {
6052       {
6053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6054       };
6055     } catch (std::exception& e) {
6056       {
6057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6058       };
6059     } catch (Dali::DaliException e) {
6060       {
6061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6066       };
6067     }
6068   }
6069
6070   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6076   void * jresult ;
6077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6078   Dali::Vector3 *arg2 = 0 ;
6079   Dali::Vector3 *result = 0 ;
6080
6081   arg1 = (Dali::Vector3 *)jarg1;
6082   arg2 = (Dali::Vector3 *)jarg2;
6083   if (!arg2) {
6084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6085     return 0;
6086   }
6087   {
6088     try {
6089       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6090     } catch (std::out_of_range& e) {
6091       {
6092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6093       };
6094     } catch (std::exception& e) {
6095       {
6096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6097       };
6098     } catch (Dali::DaliException e) {
6099       {
6100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6101       };
6102     } catch (...) {
6103       {
6104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6105       };
6106     }
6107   }
6108
6109   jresult = (void *)result;
6110   return jresult;
6111 }
6112
6113
6114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6115   void * jresult ;
6116   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6117   Dali::Vector3 *arg2 = 0 ;
6118   Dali::Vector3 result;
6119
6120   arg1 = (Dali::Vector3 *)jarg1;
6121   arg2 = (Dali::Vector3 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6129     } catch (std::out_of_range& e) {
6130       {
6131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6132       };
6133     } catch (std::exception& e) {
6134       {
6135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6136       };
6137     } catch (Dali::DaliException e) {
6138       {
6139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6140       };
6141     } catch (...) {
6142       {
6143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6144       };
6145     }
6146   }
6147
6148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6149   return jresult;
6150 }
6151
6152
6153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6154   void * jresult ;
6155   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6156   float arg2 ;
6157   Dali::Vector3 result;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   arg2 = (float)jarg2;
6161   {
6162     try {
6163       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (Dali::DaliException e) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6175       };
6176     } catch (...) {
6177       {
6178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6179       };
6180     }
6181   }
6182
6183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector3 *arg2 = 0 ;
6192   Dali::Vector3 *result = 0 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (Dali::Vector3 *)jarg2;
6196   if (!arg2) {
6197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6198     return 0;
6199   }
6200   {
6201     try {
6202       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6203     } catch (std::out_of_range& e) {
6204       {
6205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6206       };
6207     } catch (std::exception& e) {
6208       {
6209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6210       };
6211     } catch (Dali::DaliException e) {
6212       {
6213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6214       };
6215     } catch (...) {
6216       {
6217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6218       };
6219     }
6220   }
6221
6222   jresult = (void *)result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6228   void * jresult ;
6229   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6230   float arg2 ;
6231   Dali::Vector3 *result = 0 ;
6232
6233   arg1 = (Dali::Vector3 *)jarg1;
6234   arg2 = (float)jarg2;
6235   {
6236     try {
6237       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6238     } catch (std::out_of_range& e) {
6239       {
6240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6241       };
6242     } catch (std::exception& e) {
6243       {
6244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6245       };
6246     } catch (Dali::DaliException e) {
6247       {
6248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6249       };
6250     } catch (...) {
6251       {
6252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6253       };
6254     }
6255   }
6256
6257   jresult = (void *)result;
6258   return jresult;
6259 }
6260
6261
6262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6263   void * jresult ;
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   Dali::Quaternion *arg2 = 0 ;
6266   Dali::Vector3 *result = 0 ;
6267
6268   arg1 = (Dali::Vector3 *)jarg1;
6269   arg2 = (Dali::Quaternion *)jarg2;
6270   if (!arg2) {
6271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6272     return 0;
6273   }
6274   {
6275     try {
6276       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6277     } catch (std::out_of_range& e) {
6278       {
6279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6280       };
6281     } catch (std::exception& e) {
6282       {
6283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6284       };
6285     } catch (Dali::DaliException e) {
6286       {
6287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6288       };
6289     } catch (...) {
6290       {
6291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6292       };
6293     }
6294   }
6295
6296   jresult = (void *)result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6302   void * jresult ;
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   Dali::Vector3 *arg2 = 0 ;
6305   Dali::Vector3 result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (Dali::Vector3 *)jarg2;
6309   if (!arg2) {
6310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6311     return 0;
6312   }
6313   {
6314     try {
6315       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6316     } catch (std::out_of_range& e) {
6317       {
6318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6319       };
6320     } catch (std::exception& e) {
6321       {
6322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6323       };
6324     } catch (Dali::DaliException e) {
6325       {
6326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6327       };
6328     } catch (...) {
6329       {
6330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6331       };
6332     }
6333   }
6334
6335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6336   return jresult;
6337 }
6338
6339
6340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6341   void * jresult ;
6342   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6343   float arg2 ;
6344   Dali::Vector3 result;
6345
6346   arg1 = (Dali::Vector3 *)jarg1;
6347   arg2 = (float)jarg2;
6348   {
6349     try {
6350       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6351     } catch (std::out_of_range& e) {
6352       {
6353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6354       };
6355     } catch (std::exception& e) {
6356       {
6357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6358       };
6359     } catch (Dali::DaliException e) {
6360       {
6361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6362       };
6363     } catch (...) {
6364       {
6365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6366       };
6367     }
6368   }
6369
6370   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6371   return jresult;
6372 }
6373
6374
6375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6376   void * jresult ;
6377   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6378   Dali::Vector3 *arg2 = 0 ;
6379   Dali::Vector3 *result = 0 ;
6380
6381   arg1 = (Dali::Vector3 *)jarg1;
6382   arg2 = (Dali::Vector3 *)jarg2;
6383   if (!arg2) {
6384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6385     return 0;
6386   }
6387   {
6388     try {
6389       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6390     } catch (std::out_of_range& e) {
6391       {
6392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6393       };
6394     } catch (std::exception& e) {
6395       {
6396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6397       };
6398     } catch (Dali::DaliException e) {
6399       {
6400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6401       };
6402     } catch (...) {
6403       {
6404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6405       };
6406     }
6407   }
6408
6409   jresult = (void *)result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6415   void * jresult ;
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418   Dali::Vector3 *result = 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   arg2 = (float)jarg2;
6422   {
6423     try {
6424       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6425     } catch (std::out_of_range& e) {
6426       {
6427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6428       };
6429     } catch (std::exception& e) {
6430       {
6431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6432       };
6433     } catch (Dali::DaliException e) {
6434       {
6435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6436       };
6437     } catch (...) {
6438       {
6439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6440       };
6441     }
6442   }
6443
6444   jresult = (void *)result;
6445   return jresult;
6446 }
6447
6448
6449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6450   void * jresult ;
6451   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6452   Dali::Vector3 result;
6453
6454   arg1 = (Dali::Vector3 *)jarg1;
6455   {
6456     try {
6457       result = ((Dali::Vector3 const *)arg1)->operator -();
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (Dali::DaliException e) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6469       };
6470     } catch (...) {
6471       {
6472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6473       };
6474     }
6475   }
6476
6477   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6478   return jresult;
6479 }
6480
6481
6482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6483   unsigned int jresult ;
6484   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6485   Dali::Vector3 *arg2 = 0 ;
6486   bool result;
6487
6488   arg1 = (Dali::Vector3 *)jarg1;
6489   arg2 = (Dali::Vector3 *)jarg2;
6490   if (!arg2) {
6491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6492     return 0;
6493   }
6494   {
6495     try {
6496       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6497     } catch (std::out_of_range& e) {
6498       {
6499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6500       };
6501     } catch (std::exception& e) {
6502       {
6503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (Dali::DaliException e) {
6506       {
6507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515
6516   jresult = result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6522   unsigned int jresult ;
6523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6524   Dali::Vector3 *arg2 = 0 ;
6525   bool result;
6526
6527   arg1 = (Dali::Vector3 *)jarg1;
6528   arg2 = (Dali::Vector3 *)jarg2;
6529   if (!arg2) {
6530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6531     return 0;
6532   }
6533   {
6534     try {
6535       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6536     } catch (std::out_of_range& e) {
6537       {
6538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6539       };
6540     } catch (std::exception& e) {
6541       {
6542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6543       };
6544     } catch (Dali::DaliException e) {
6545       {
6546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6547       };
6548     } catch (...) {
6549       {
6550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6551       };
6552     }
6553   }
6554
6555   jresult = result;
6556   return jresult;
6557 }
6558
6559
6560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6561   float jresult ;
6562   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6563   unsigned int arg2 ;
6564   float *result = 0 ;
6565
6566   arg1 = (Dali::Vector3 *)jarg1;
6567   arg2 = (unsigned int)jarg2;
6568   {
6569     try {
6570       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6571     } catch (std::out_of_range& e) {
6572       {
6573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6574       };
6575     } catch (std::exception& e) {
6576       {
6577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6578       };
6579     } catch (Dali::DaliException e) {
6580       {
6581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6582       };
6583     } catch (...) {
6584       {
6585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6586       };
6587     }
6588   }
6589
6590   jresult = *result;
6591   return jresult;
6592 }
6593
6594
6595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6596   float jresult ;
6597   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6598   Dali::Vector3 *arg2 = 0 ;
6599   float result;
6600
6601   arg1 = (Dali::Vector3 *)jarg1;
6602   arg2 = (Dali::Vector3 *)jarg2;
6603   if (!arg2) {
6604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6605     return 0;
6606   }
6607   {
6608     try {
6609       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (Dali::DaliException e) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6621       };
6622     } catch (...) {
6623       {
6624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6625       };
6626     }
6627   }
6628
6629   jresult = result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6635   void * jresult ;
6636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6637   Dali::Vector3 *arg2 = 0 ;
6638   Dali::Vector3 result;
6639
6640   arg1 = (Dali::Vector3 *)jarg1;
6641   arg2 = (Dali::Vector3 *)jarg2;
6642   if (!arg2) {
6643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6644     return 0;
6645   }
6646   {
6647     try {
6648       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6649     } catch (std::out_of_range& e) {
6650       {
6651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6652       };
6653     } catch (std::exception& e) {
6654       {
6655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6656       };
6657     } catch (Dali::DaliException e) {
6658       {
6659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6660       };
6661     } catch (...) {
6662       {
6663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6664       };
6665     }
6666   }
6667
6668   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6669   return jresult;
6670 }
6671
6672
6673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6674   float jresult ;
6675   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6676   float result;
6677
6678   arg1 = (Dali::Vector3 *)jarg1;
6679   {
6680     try {
6681       result = (float)((Dali::Vector3 const *)arg1)->Length();
6682     } catch (std::out_of_range& e) {
6683       {
6684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (std::exception& e) {
6687       {
6688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6689       };
6690     } catch (Dali::DaliException e) {
6691       {
6692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6693       };
6694     } catch (...) {
6695       {
6696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6697       };
6698     }
6699   }
6700
6701   jresult = result;
6702   return jresult;
6703 }
6704
6705
6706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6707   float jresult ;
6708   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6709   float result;
6710
6711   arg1 = (Dali::Vector3 *)jarg1;
6712   {
6713     try {
6714       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6715     } catch (std::out_of_range& e) {
6716       {
6717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (std::exception& e) {
6720       {
6721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6722       };
6723     } catch (Dali::DaliException e) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6726       };
6727     } catch (...) {
6728       {
6729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6730       };
6731     }
6732   }
6733
6734   jresult = result;
6735   return jresult;
6736 }
6737
6738
6739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6740   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6741
6742   arg1 = (Dali::Vector3 *)jarg1;
6743   {
6744     try {
6745       (arg1)->Normalize();
6746     } catch (std::out_of_range& e) {
6747       {
6748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6749       };
6750     } catch (std::exception& e) {
6751       {
6752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6753       };
6754     } catch (Dali::DaliException e) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6757       };
6758     } catch (...) {
6759       {
6760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6761       };
6762     }
6763   }
6764
6765 }
6766
6767
6768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6769   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6770   Dali::Vector3 *arg2 = 0 ;
6771   Dali::Vector3 *arg3 = 0 ;
6772
6773   arg1 = (Dali::Vector3 *)jarg1;
6774   arg2 = (Dali::Vector3 *)jarg2;
6775   if (!arg2) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   arg3 = (Dali::Vector3 *)jarg3;
6780   if (!arg3) {
6781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6782     return ;
6783   }
6784   {
6785     try {
6786       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6787     } catch (std::out_of_range& e) {
6788       {
6789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6790       };
6791     } catch (std::exception& e) {
6792       {
6793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6794       };
6795     } catch (Dali::DaliException e) {
6796       {
6797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6798       };
6799     } catch (...) {
6800       {
6801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6802       };
6803     }
6804   }
6805
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6810   void * jresult ;
6811   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6812   float *result = 0 ;
6813
6814   arg1 = (Dali::Vector3 *)jarg1;
6815   {
6816     try {
6817       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6818     } catch (std::out_of_range& e) {
6819       {
6820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6821       };
6822     } catch (std::exception& e) {
6823       {
6824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6825       };
6826     } catch (Dali::DaliException e) {
6827       {
6828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6829       };
6830     } catch (...) {
6831       {
6832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6833       };
6834     }
6835   }
6836
6837   jresult = (void *)result;
6838   return jresult;
6839 }
6840
6841
6842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6843   void * jresult ;
6844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6845   Dali::Vector2 *result = 0 ;
6846
6847   arg1 = (Dali::Vector3 *)jarg1;
6848   {
6849     try {
6850       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6851     } catch (std::out_of_range& e) {
6852       {
6853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (std::exception& e) {
6856       {
6857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6858       };
6859     } catch (Dali::DaliException e) {
6860       {
6861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6862       };
6863     } catch (...) {
6864       {
6865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6866       };
6867     }
6868   }
6869
6870   jresult = (void *)result;
6871   return jresult;
6872 }
6873
6874
6875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6876   void * jresult ;
6877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6878   Dali::Vector2 *result = 0 ;
6879
6880   arg1 = (Dali::Vector3 *)jarg1;
6881   {
6882     try {
6883       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6884     } catch (std::out_of_range& e) {
6885       {
6886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (std::exception& e) {
6889       {
6890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6891       };
6892     } catch (Dali::DaliException e) {
6893       {
6894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6895       };
6896     } catch (...) {
6897       {
6898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6899       };
6900     }
6901   }
6902
6903   jresult = (void *)result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->x = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->x);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->width = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->width);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->r = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->r);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->y = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->y);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->height = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->height);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->g = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->g);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->z = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->z);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064   float arg2 ;
7065
7066   arg1 = (Dali::Vector3 *)jarg1;
7067   arg2 = (float)jarg2;
7068   if (arg1) (arg1)->depth = arg2;
7069 }
7070
7071
7072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7073   float jresult ;
7074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7075   float result;
7076
7077   arg1 = (Dali::Vector3 *)jarg1;
7078   result = (float) ((arg1)->depth);
7079   jresult = result;
7080   return jresult;
7081 }
7082
7083
7084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7086   float arg2 ;
7087
7088   arg1 = (Dali::Vector3 *)jarg1;
7089   arg2 = (float)jarg2;
7090   if (arg1) (arg1)->b = arg2;
7091 }
7092
7093
7094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7095   float jresult ;
7096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7097   float result;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   result = (float) ((arg1)->b);
7101   jresult = result;
7102   return jresult;
7103 }
7104
7105
7106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7107   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7108
7109   arg1 = (Dali::Vector3 *)jarg1;
7110   {
7111     try {
7112       delete arg1;
7113     } catch (std::out_of_range& e) {
7114       {
7115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7116       };
7117     } catch (std::exception& e) {
7118       {
7119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7120       };
7121     } catch (Dali::DaliException e) {
7122       {
7123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7124       };
7125     } catch (...) {
7126       {
7127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7128       };
7129     }
7130   }
7131
7132 }
7133
7134
7135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7136   void * jresult ;
7137   Dali::Vector3 *arg1 = 0 ;
7138   Dali::Vector3 *arg2 = 0 ;
7139   Dali::Vector3 result;
7140
7141   arg1 = (Dali::Vector3 *)jarg1;
7142   if (!arg1) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   arg2 = (Dali::Vector3 *)jarg2;
7147   if (!arg2) {
7148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7149     return 0;
7150   }
7151   {
7152     try {
7153       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (Dali::DaliException e) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7165       };
7166     } catch (...) {
7167       {
7168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7169       };
7170     }
7171   }
7172
7173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7174   return jresult;
7175 }
7176
7177
7178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7179   void * jresult ;
7180   Dali::Vector3 *arg1 = 0 ;
7181   Dali::Vector3 *arg2 = 0 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   arg2 = (Dali::Vector3 *)jarg2;
7190   if (!arg2) {
7191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7192     return 0;
7193   }
7194   {
7195     try {
7196       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7197     } catch (std::out_of_range& e) {
7198       {
7199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7200       };
7201     } catch (std::exception& e) {
7202       {
7203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (Dali::DaliException e) {
7206       {
7207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215
7216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7222   void * jresult ;
7223   Dali::Vector3 *arg1 = 0 ;
7224   float *arg2 = 0 ;
7225   float *arg3 = 0 ;
7226   float temp2 ;
7227   float temp3 ;
7228   Dali::Vector3 result;
7229
7230   arg1 = (Dali::Vector3 *)jarg1;
7231   if (!arg1) {
7232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7233     return 0;
7234   }
7235   temp2 = (float)jarg2;
7236   arg2 = &temp2;
7237   temp3 = (float)jarg3;
7238   arg3 = &temp3;
7239   {
7240     try {
7241       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7242     } catch (std::out_of_range& e) {
7243       {
7244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7245       };
7246     } catch (std::exception& e) {
7247       {
7248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7249       };
7250     } catch (Dali::DaliException e) {
7251       {
7252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7253       };
7254     } catch (...) {
7255       {
7256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7257       };
7258     }
7259   }
7260
7261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7262   return jresult;
7263 }
7264
7265
7266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7267   void * jresult ;
7268   Dali::Vector4 *result = 0 ;
7269
7270   {
7271     try {
7272       result = (Dali::Vector4 *)new Dali::Vector4();
7273     } catch (std::out_of_range& e) {
7274       {
7275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7276       };
7277     } catch (std::exception& e) {
7278       {
7279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7280       };
7281     } catch (Dali::DaliException e) {
7282       {
7283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7284       };
7285     } catch (...) {
7286       {
7287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7288       };
7289     }
7290   }
7291
7292   jresult = (void *)result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7298   void * jresult ;
7299   float arg1 ;
7300   float arg2 ;
7301   float arg3 ;
7302   float arg4 ;
7303   Dali::Vector4 *result = 0 ;
7304
7305   arg1 = (float)jarg1;
7306   arg2 = (float)jarg2;
7307   arg3 = (float)jarg3;
7308   arg4 = (float)jarg4;
7309   {
7310     try {
7311       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (Dali::DaliException e) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330
7331   jresult = (void *)result;
7332   return jresult;
7333 }
7334
7335
7336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7337   void * jresult ;
7338   float *arg1 = (float *) 0 ;
7339   Dali::Vector4 *result = 0 ;
7340
7341   arg1 = jarg1;
7342   {
7343     try {
7344       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7345     } catch (std::out_of_range& e) {
7346       {
7347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7348       };
7349     } catch (std::exception& e) {
7350       {
7351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (Dali::DaliException e) {
7354       {
7355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7356       };
7357     } catch (...) {
7358       {
7359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7360       };
7361     }
7362   }
7363
7364   jresult = (void *)result;
7365
7366
7367   return jresult;
7368 }
7369
7370
7371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7372   void * jresult ;
7373   Dali::Vector2 *arg1 = 0 ;
7374   Dali::Vector4 *result = 0 ;
7375
7376   arg1 = (Dali::Vector2 *)jarg1;
7377   if (!arg1) {
7378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7379     return 0;
7380   }
7381   {
7382     try {
7383       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7384     } catch (std::out_of_range& e) {
7385       {
7386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (std::exception& e) {
7389       {
7390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7391       };
7392     } catch (Dali::DaliException e) {
7393       {
7394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7395       };
7396     } catch (...) {
7397       {
7398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7399       };
7400     }
7401   }
7402
7403   jresult = (void *)result;
7404   return jresult;
7405 }
7406
7407
7408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7409   void * jresult ;
7410   Dali::Vector3 *arg1 = 0 ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   arg1 = (Dali::Vector3 *)jarg1;
7414   if (!arg1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7416     return 0;
7417   }
7418   {
7419     try {
7420       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7421     } catch (std::out_of_range& e) {
7422       {
7423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7424       };
7425     } catch (std::exception& e) {
7426       {
7427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (Dali::DaliException e) {
7430       {
7431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7486   void * jresult ;
7487   Dali::Vector4 *result = 0 ;
7488
7489   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7490   jresult = (void *)result;
7491   return jresult;
7492 }
7493
7494
7495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7496   void * jresult ;
7497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7498   float *arg2 = (float *) 0 ;
7499   Dali::Vector4 *result = 0 ;
7500
7501   arg1 = (Dali::Vector4 *)jarg1;
7502   arg2 = jarg2;
7503   {
7504     try {
7505       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7506     } catch (std::out_of_range& e) {
7507       {
7508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (std::exception& e) {
7511       {
7512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7513       };
7514     } catch (Dali::DaliException e) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7517       };
7518     } catch (...) {
7519       {
7520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7521       };
7522     }
7523   }
7524
7525   jresult = (void *)result;
7526
7527
7528   return jresult;
7529 }
7530
7531
7532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7533   void * jresult ;
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   Dali::Vector2 *arg2 = 0 ;
7536   Dali::Vector4 *result = 0 ;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   arg2 = (Dali::Vector2 *)jarg2;
7540   if (!arg2) {
7541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7542     return 0;
7543   }
7544   {
7545     try {
7546       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7547     } catch (std::out_of_range& e) {
7548       {
7549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7550       };
7551     } catch (std::exception& e) {
7552       {
7553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7554       };
7555     } catch (Dali::DaliException e) {
7556       {
7557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7562       };
7563     }
7564   }
7565
7566   jresult = (void *)result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7572   void * jresult ;
7573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7574   Dali::Vector3 *arg2 = 0 ;
7575   Dali::Vector4 *result = 0 ;
7576
7577   arg1 = (Dali::Vector4 *)jarg1;
7578   arg2 = (Dali::Vector3 *)jarg2;
7579   if (!arg2) {
7580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7581     return 0;
7582   }
7583   {
7584     try {
7585       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7586     } catch (std::out_of_range& e) {
7587       {
7588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7589       };
7590     } catch (std::exception& e) {
7591       {
7592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7593       };
7594     } catch (Dali::DaliException e) {
7595       {
7596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7597       };
7598     } catch (...) {
7599       {
7600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7601       };
7602     }
7603   }
7604
7605   jresult = (void *)result;
7606   return jresult;
7607 }
7608
7609
7610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7611   void * jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   Dali::Vector4 *arg2 = 0 ;
7614   Dali::Vector4 result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   arg2 = (Dali::Vector4 *)jarg2;
7618   if (!arg2) {
7619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7620     return 0;
7621   }
7622   {
7623     try {
7624       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7625     } catch (std::out_of_range& e) {
7626       {
7627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7628       };
7629     } catch (std::exception& e) {
7630       {
7631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7632       };
7633     } catch (Dali::DaliException e) {
7634       {
7635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7636       };
7637     } catch (...) {
7638       {
7639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7640       };
7641     }
7642   }
7643
7644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7645   return jresult;
7646 }
7647
7648
7649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7650   void * jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   Dali::Vector4 *arg2 = 0 ;
7653   Dali::Vector4 *result = 0 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   arg2 = (Dali::Vector4 *)jarg2;
7657   if (!arg2) {
7658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7659     return 0;
7660   }
7661   {
7662     try {
7663       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7664     } catch (std::out_of_range& e) {
7665       {
7666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (std::exception& e) {
7669       {
7670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7671       };
7672     } catch (Dali::DaliException e) {
7673       {
7674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7675       };
7676     } catch (...) {
7677       {
7678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7679       };
7680     }
7681   }
7682
7683   jresult = (void *)result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7689   void * jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   Dali::Vector4 *arg2 = 0 ;
7692   Dali::Vector4 result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   arg2 = (Dali::Vector4 *)jarg2;
7696   if (!arg2) {
7697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7698     return 0;
7699   }
7700   {
7701     try {
7702       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7703     } catch (std::out_of_range& e) {
7704       {
7705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7706       };
7707     } catch (std::exception& e) {
7708       {
7709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7710       };
7711     } catch (Dali::DaliException e) {
7712       {
7713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7714       };
7715     } catch (...) {
7716       {
7717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7718       };
7719     }
7720   }
7721
7722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7728   void * jresult ;
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   Dali::Vector4 *arg2 = 0 ;
7731   Dali::Vector4 *result = 0 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (Dali::Vector4 *)jarg2;
7735   if (!arg2) {
7736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7737     return 0;
7738   }
7739   {
7740     try {
7741       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7742     } catch (std::out_of_range& e) {
7743       {
7744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7745       };
7746     } catch (std::exception& e) {
7747       {
7748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7749       };
7750     } catch (Dali::DaliException e) {
7751       {
7752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7753       };
7754     } catch (...) {
7755       {
7756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7757       };
7758     }
7759   }
7760
7761   jresult = (void *)result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7767   void * jresult ;
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   Dali::Vector4 *arg2 = 0 ;
7770   Dali::Vector4 result;
7771
7772   arg1 = (Dali::Vector4 *)jarg1;
7773   arg2 = (Dali::Vector4 *)jarg2;
7774   if (!arg2) {
7775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7776     return 0;
7777   }
7778   {
7779     try {
7780       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7781     } catch (std::out_of_range& e) {
7782       {
7783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7784       };
7785     } catch (std::exception& e) {
7786       {
7787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7788       };
7789     } catch (Dali::DaliException e) {
7790       {
7791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7792       };
7793     } catch (...) {
7794       {
7795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7796       };
7797     }
7798   }
7799
7800   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7801   return jresult;
7802 }
7803
7804
7805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7806   void * jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809   Dali::Vector4 result;
7810
7811   arg1 = (Dali::Vector4 *)jarg1;
7812   arg2 = (float)jarg2;
7813   {
7814     try {
7815       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7816     } catch (std::out_of_range& e) {
7817       {
7818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7819       };
7820     } catch (std::exception& e) {
7821       {
7822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7823       };
7824     } catch (Dali::DaliException e) {
7825       {
7826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7827       };
7828     } catch (...) {
7829       {
7830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7831       };
7832     }
7833   }
7834
7835   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7841   void * jresult ;
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843   Dali::Vector4 *arg2 = 0 ;
7844   Dali::Vector4 *result = 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   arg2 = (Dali::Vector4 *)jarg2;
7848   if (!arg2) {
7849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7850     return 0;
7851   }
7852   {
7853     try {
7854       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7855     } catch (std::out_of_range& e) {
7856       {
7857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7858       };
7859     } catch (std::exception& e) {
7860       {
7861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7862       };
7863     } catch (Dali::DaliException e) {
7864       {
7865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7866       };
7867     } catch (...) {
7868       {
7869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7870       };
7871     }
7872   }
7873
7874   jresult = (void *)result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7880   void * jresult ;
7881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7882   float arg2 ;
7883   Dali::Vector4 *result = 0 ;
7884
7885   arg1 = (Dali::Vector4 *)jarg1;
7886   arg2 = (float)jarg2;
7887   {
7888     try {
7889       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7890     } catch (std::out_of_range& e) {
7891       {
7892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (std::exception& e) {
7895       {
7896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7897       };
7898     } catch (Dali::DaliException e) {
7899       {
7900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7901       };
7902     } catch (...) {
7903       {
7904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7905       };
7906     }
7907   }
7908
7909   jresult = (void *)result;
7910   return jresult;
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7915   void * jresult ;
7916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7917   Dali::Vector4 *arg2 = 0 ;
7918   Dali::Vector4 result;
7919
7920   arg1 = (Dali::Vector4 *)jarg1;
7921   arg2 = (Dali::Vector4 *)jarg2;
7922   if (!arg2) {
7923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7924     return 0;
7925   }
7926   {
7927     try {
7928       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7929     } catch (std::out_of_range& e) {
7930       {
7931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7932       };
7933     } catch (std::exception& e) {
7934       {
7935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7936       };
7937     } catch (Dali::DaliException e) {
7938       {
7939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7940       };
7941     } catch (...) {
7942       {
7943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7944       };
7945     }
7946   }
7947
7948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7949   return jresult;
7950 }
7951
7952
7953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7954   void * jresult ;
7955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7956   float arg2 ;
7957   Dali::Vector4 result;
7958
7959   arg1 = (Dali::Vector4 *)jarg1;
7960   arg2 = (float)jarg2;
7961   {
7962     try {
7963       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (Dali::DaliException e) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7975       };
7976     } catch (...) {
7977       {
7978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7979       };
7980     }
7981   }
7982
7983   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7984   return jresult;
7985 }
7986
7987
7988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7989   void * jresult ;
7990   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7991   Dali::Vector4 *arg2 = 0 ;
7992   Dali::Vector4 *result = 0 ;
7993
7994   arg1 = (Dali::Vector4 *)jarg1;
7995   arg2 = (Dali::Vector4 *)jarg2;
7996   if (!arg2) {
7997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7998     return 0;
7999   }
8000   {
8001     try {
8002       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8003     } catch (std::out_of_range& e) {
8004       {
8005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8006       };
8007     } catch (std::exception& e) {
8008       {
8009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (Dali::DaliException e) {
8012       {
8013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021
8022   jresult = (void *)result;
8023   return jresult;
8024 }
8025
8026
8027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8028   void * jresult ;
8029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8030   float arg2 ;
8031   Dali::Vector4 *result = 0 ;
8032
8033   arg1 = (Dali::Vector4 *)jarg1;
8034   arg2 = (float)jarg2;
8035   {
8036     try {
8037       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8038     } catch (std::out_of_range& e) {
8039       {
8040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8041       };
8042     } catch (std::exception& e) {
8043       {
8044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8045       };
8046     } catch (Dali::DaliException e) {
8047       {
8048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8049       };
8050     } catch (...) {
8051       {
8052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8053       };
8054     }
8055   }
8056
8057   jresult = (void *)result;
8058   return jresult;
8059 }
8060
8061
8062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8063   void * jresult ;
8064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8065   Dali::Vector4 result;
8066
8067   arg1 = (Dali::Vector4 *)jarg1;
8068   {
8069     try {
8070       result = ((Dali::Vector4 const *)arg1)->operator -();
8071     } catch (std::out_of_range& e) {
8072       {
8073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (std::exception& e) {
8076       {
8077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8078       };
8079     } catch (Dali::DaliException e) {
8080       {
8081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8082       };
8083     } catch (...) {
8084       {
8085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8086       };
8087     }
8088   }
8089
8090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8091   return jresult;
8092 }
8093
8094
8095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8096   unsigned int jresult ;
8097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8098   Dali::Vector4 *arg2 = 0 ;
8099   bool result;
8100
8101   arg1 = (Dali::Vector4 *)jarg1;
8102   arg2 = (Dali::Vector4 *)jarg2;
8103   if (!arg2) {
8104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8105     return 0;
8106   }
8107   {
8108     try {
8109       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8110     } catch (std::out_of_range& e) {
8111       {
8112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (std::exception& e) {
8115       {
8116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8117       };
8118     } catch (Dali::DaliException e) {
8119       {
8120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8121       };
8122     } catch (...) {
8123       {
8124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8125       };
8126     }
8127   }
8128
8129   jresult = result;
8130   return jresult;
8131 }
8132
8133
8134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8135   unsigned int jresult ;
8136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8137   Dali::Vector4 *arg2 = 0 ;
8138   bool result;
8139
8140   arg1 = (Dali::Vector4 *)jarg1;
8141   arg2 = (Dali::Vector4 *)jarg2;
8142   if (!arg2) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8144     return 0;
8145   }
8146   {
8147     try {
8148       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8149     } catch (std::out_of_range& e) {
8150       {
8151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (std::exception& e) {
8154       {
8155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8156       };
8157     } catch (Dali::DaliException e) {
8158       {
8159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8160       };
8161     } catch (...) {
8162       {
8163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8164       };
8165     }
8166   }
8167
8168   jresult = result;
8169   return jresult;
8170 }
8171
8172
8173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8174   float jresult ;
8175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8176   unsigned int arg2 ;
8177   float *result = 0 ;
8178
8179   arg1 = (Dali::Vector4 *)jarg1;
8180   arg2 = (unsigned int)jarg2;
8181   {
8182     try {
8183       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8184     } catch (std::out_of_range& e) {
8185       {
8186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8187       };
8188     } catch (std::exception& e) {
8189       {
8190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8191       };
8192     } catch (Dali::DaliException e) {
8193       {
8194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8199       };
8200     }
8201   }
8202
8203   jresult = *result;
8204   return jresult;
8205 }
8206
8207
8208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8209   float jresult ;
8210   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   float result;
8213
8214   arg1 = (Dali::Vector4 *)jarg1;
8215   arg2 = (Dali::Vector3 *)jarg2;
8216   if (!arg2) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8218     return 0;
8219   }
8220   {
8221     try {
8222       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8223     } catch (std::out_of_range& e) {
8224       {
8225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8226       };
8227     } catch (std::exception& e) {
8228       {
8229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8230       };
8231     } catch (Dali::DaliException e) {
8232       {
8233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8238       };
8239     }
8240   }
8241
8242   jresult = result;
8243   return jresult;
8244 }
8245
8246
8247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8248   float jresult ;
8249   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8250   Dali::Vector4 *arg2 = 0 ;
8251   float result;
8252
8253   arg1 = (Dali::Vector4 *)jarg1;
8254   arg2 = (Dali::Vector4 *)jarg2;
8255   if (!arg2) {
8256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8257     return 0;
8258   }
8259   {
8260     try {
8261       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8262     } catch (std::out_of_range& e) {
8263       {
8264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8265       };
8266     } catch (std::exception& e) {
8267       {
8268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (Dali::DaliException e) {
8271       {
8272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8273       };
8274     } catch (...) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8277       };
8278     }
8279   }
8280
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8287   float jresult ;
8288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8289   Dali::Vector4 *arg2 = 0 ;
8290   float result;
8291
8292   arg1 = (Dali::Vector4 *)jarg1;
8293   arg2 = (Dali::Vector4 *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (Dali::DaliException e) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8312       };
8313     } catch (...) {
8314       {
8315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8316       };
8317     }
8318   }
8319
8320   jresult = result;
8321   return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8326   void * jresult ;
8327   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8328   Dali::Vector4 *arg2 = 0 ;
8329   Dali::Vector4 result;
8330
8331   arg1 = (Dali::Vector4 *)jarg1;
8332   arg2 = (Dali::Vector4 *)jarg2;
8333   if (!arg2) {
8334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8335     return 0;
8336   }
8337   {
8338     try {
8339       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8340     } catch (std::out_of_range& e) {
8341       {
8342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (std::exception& e) {
8345       {
8346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8347       };
8348     } catch (Dali::DaliException e) {
8349       {
8350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8351       };
8352     } catch (...) {
8353       {
8354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8355       };
8356     }
8357   }
8358
8359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8365   float jresult ;
8366   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8367   float result;
8368
8369   arg1 = (Dali::Vector4 *)jarg1;
8370   {
8371     try {
8372       result = (float)((Dali::Vector4 const *)arg1)->Length();
8373     } catch (std::out_of_range& e) {
8374       {
8375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (std::exception& e) {
8378       {
8379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8380       };
8381     } catch (Dali::DaliException e) {
8382       {
8383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8384       };
8385     } catch (...) {
8386       {
8387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8388       };
8389     }
8390   }
8391
8392   jresult = result;
8393   return jresult;
8394 }
8395
8396
8397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8398   float jresult ;
8399   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8400   float result;
8401
8402   arg1 = (Dali::Vector4 *)jarg1;
8403   {
8404     try {
8405       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8406     } catch (std::out_of_range& e) {
8407       {
8408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (std::exception& e) {
8411       {
8412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8413       };
8414     } catch (Dali::DaliException e) {
8415       {
8416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8417       };
8418     } catch (...) {
8419       {
8420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8421       };
8422     }
8423   }
8424
8425   jresult = result;
8426   return jresult;
8427 }
8428
8429
8430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8431   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8432
8433   arg1 = (Dali::Vector4 *)jarg1;
8434   {
8435     try {
8436       (arg1)->Normalize();
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8444       };
8445     } catch (Dali::DaliException e) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8448       };
8449     } catch (...) {
8450       {
8451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8452       };
8453     }
8454   }
8455
8456 }
8457
8458
8459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8461   Dali::Vector4 *arg2 = 0 ;
8462   Dali::Vector4 *arg3 = 0 ;
8463
8464   arg1 = (Dali::Vector4 *)jarg1;
8465   arg2 = (Dali::Vector4 *)jarg2;
8466   if (!arg2) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   arg3 = (Dali::Vector4 *)jarg3;
8471   if (!arg3) {
8472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8473     return ;
8474   }
8475   {
8476     try {
8477       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8478     } catch (std::out_of_range& e) {
8479       {
8480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8481       };
8482     } catch (std::exception& e) {
8483       {
8484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8485       };
8486     } catch (Dali::DaliException e) {
8487       {
8488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8489       };
8490     } catch (...) {
8491       {
8492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8493       };
8494     }
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8501   void * jresult ;
8502   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8503   float *result = 0 ;
8504
8505   arg1 = (Dali::Vector4 *)jarg1;
8506   {
8507     try {
8508       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8509     } catch (std::out_of_range& e) {
8510       {
8511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (std::exception& e) {
8514       {
8515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8516       };
8517     } catch (Dali::DaliException e) {
8518       {
8519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8520       };
8521     } catch (...) {
8522       {
8523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8524       };
8525     }
8526   }
8527
8528   jresult = (void *)result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->x = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->x);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->r = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->r);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->s = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->s);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->y = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->y);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->g = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->g);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->t = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->t);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->z = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->z);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->b = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->b);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->p = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->p);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->w = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->w);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755   float arg2 ;
8756
8757   arg1 = (Dali::Vector4 *)jarg1;
8758   arg2 = (float)jarg2;
8759   if (arg1) (arg1)->a = arg2;
8760 }
8761
8762
8763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8764   float jresult ;
8765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8766   float result;
8767
8768   arg1 = (Dali::Vector4 *)jarg1;
8769   result = (float) ((arg1)->a);
8770   jresult = result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8777   float arg2 ;
8778
8779   arg1 = (Dali::Vector4 *)jarg1;
8780   arg2 = (float)jarg2;
8781   if (arg1) (arg1)->q = arg2;
8782 }
8783
8784
8785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8786   float jresult ;
8787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8788   float result;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   result = (float) ((arg1)->q);
8792   jresult = result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8799
8800   arg1 = (Dali::Vector4 *)jarg1;
8801   {
8802     try {
8803       delete arg1;
8804     } catch (std::out_of_range& e) {
8805       {
8806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8807       };
8808     } catch (std::exception& e) {
8809       {
8810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8811       };
8812     } catch (Dali::DaliException e) {
8813       {
8814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8819       };
8820     }
8821   }
8822
8823 }
8824
8825
8826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8827   void * jresult ;
8828   Dali::Vector4 *arg1 = 0 ;
8829   Dali::Vector4 *arg2 = 0 ;
8830   Dali::Vector4 result;
8831
8832   arg1 = (Dali::Vector4 *)jarg1;
8833   if (!arg1) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   arg2 = (Dali::Vector4 *)jarg2;
8838   if (!arg2) {
8839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8840     return 0;
8841   }
8842   {
8843     try {
8844       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8845     } catch (std::out_of_range& e) {
8846       {
8847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (std::exception& e) {
8850       {
8851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8852       };
8853     } catch (Dali::DaliException e) {
8854       {
8855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8856       };
8857     } catch (...) {
8858       {
8859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8860       };
8861     }
8862   }
8863
8864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8870   void * jresult ;
8871   Dali::Vector4 *arg1 = 0 ;
8872   Dali::Vector4 *arg2 = 0 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   arg2 = (Dali::Vector4 *)jarg2;
8881   if (!arg2) {
8882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8883     return 0;
8884   }
8885   {
8886     try {
8887       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8888     } catch (std::out_of_range& e) {
8889       {
8890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (std::exception& e) {
8893       {
8894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (Dali::DaliException e) {
8897       {
8898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906
8907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8913   void * jresult ;
8914   Dali::Vector4 *arg1 = 0 ;
8915   float *arg2 = 0 ;
8916   float *arg3 = 0 ;
8917   float temp2 ;
8918   float temp3 ;
8919   Dali::Vector4 result;
8920
8921   arg1 = (Dali::Vector4 *)jarg1;
8922   if (!arg1) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8924     return 0;
8925   }
8926   temp2 = (float)jarg2;
8927   arg2 = &temp2;
8928   temp3 = (float)jarg3;
8929   arg3 = &temp3;
8930   {
8931     try {
8932       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (Dali::DaliException e) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8944       };
8945     } catch (...) {
8946       {
8947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8948       };
8949     }
8950   }
8951
8952   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8953   return jresult;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8958   void * jresult ;
8959   Dali::Uint16Pair *result = 0 ;
8960
8961   {
8962     try {
8963       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (Dali::DaliException e) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8975       };
8976     } catch (...) {
8977       {
8978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8979       };
8980     }
8981   }
8982
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8989   void * jresult ;
8990   uint32_t arg1 ;
8991   uint32_t arg2 ;
8992   Dali::Uint16Pair *result = 0 ;
8993
8994   arg1 = (uint32_t)jarg1;
8995   arg2 = (uint32_t)jarg2;
8996   {
8997     try {
8998       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8999     } catch (std::out_of_range& e) {
9000       {
9001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (std::exception& e) {
9004       {
9005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9006       };
9007     } catch (Dali::DaliException e) {
9008       {
9009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9010       };
9011     } catch (...) {
9012       {
9013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9014       };
9015     }
9016   }
9017
9018   jresult = (void *)result;
9019   return jresult;
9020 }
9021
9022
9023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9024   void * jresult ;
9025   Dali::Uint16Pair *arg1 = 0 ;
9026   Dali::Uint16Pair *result = 0 ;
9027
9028   arg1 = (Dali::Uint16Pair *)jarg1;
9029   if (!arg1) {
9030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9031     return 0;
9032   }
9033   {
9034     try {
9035       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9036     } catch (std::out_of_range& e) {
9037       {
9038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9039       };
9040     } catch (std::exception& e) {
9041       {
9042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9043       };
9044     } catch (Dali::DaliException e) {
9045       {
9046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9047       };
9048     } catch (...) {
9049       {
9050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9051       };
9052     }
9053   }
9054
9055   jresult = (void *)result;
9056   return jresult;
9057 }
9058
9059
9060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9061   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9062   uint16_t arg2 ;
9063
9064   arg1 = (Dali::Uint16Pair *)jarg1;
9065   arg2 = (uint16_t)jarg2;
9066   {
9067     try {
9068       (arg1)->SetWidth(arg2);
9069     } catch (std::out_of_range& e) {
9070       {
9071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9072       };
9073     } catch (std::exception& e) {
9074       {
9075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9076       };
9077     } catch (Dali::DaliException e) {
9078       {
9079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9080       };
9081     } catch (...) {
9082       {
9083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9084       };
9085     }
9086   }
9087
9088 }
9089
9090
9091 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9092   unsigned short jresult ;
9093   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9094   uint16_t result;
9095
9096   arg1 = (Dali::Uint16Pair *)jarg1;
9097   {
9098     try {
9099       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (Dali::DaliException e) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9111       };
9112     } catch (...) {
9113       {
9114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9115       };
9116     }
9117   }
9118
9119   jresult = result;
9120   return jresult;
9121 }
9122
9123
9124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9126   uint16_t arg2 ;
9127
9128   arg1 = (Dali::Uint16Pair *)jarg1;
9129   arg2 = (uint16_t)jarg2;
9130   {
9131     try {
9132       (arg1)->SetHeight(arg2);
9133     } catch (std::out_of_range& e) {
9134       {
9135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9136       };
9137     } catch (std::exception& e) {
9138       {
9139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (Dali::DaliException e) {
9142       {
9143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151
9152 }
9153
9154
9155 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9156   unsigned short jresult ;
9157   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9158   uint16_t result;
9159
9160   arg1 = (Dali::Uint16Pair *)jarg1;
9161   {
9162     try {
9163       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9164     } catch (std::out_of_range& e) {
9165       {
9166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9167       };
9168     } catch (std::exception& e) {
9169       {
9170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9171       };
9172     } catch (Dali::DaliException e) {
9173       {
9174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9175       };
9176     } catch (...) {
9177       {
9178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9179       };
9180     }
9181   }
9182
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9189   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9190   uint16_t arg2 ;
9191
9192   arg1 = (Dali::Uint16Pair *)jarg1;
9193   arg2 = (uint16_t)jarg2;
9194   {
9195     try {
9196       (arg1)->SetX(arg2);
9197     } catch (std::out_of_range& e) {
9198       {
9199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9200       };
9201     } catch (std::exception& e) {
9202       {
9203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9204       };
9205     } catch (Dali::DaliException e) {
9206       {
9207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9212       };
9213     }
9214   }
9215
9216 }
9217
9218
9219 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9220   unsigned short jresult ;
9221   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9222   uint16_t result;
9223
9224   arg1 = (Dali::Uint16Pair *)jarg1;
9225   {
9226     try {
9227       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9228     } catch (std::out_of_range& e) {
9229       {
9230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (std::exception& e) {
9233       {
9234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9235       };
9236     } catch (Dali::DaliException e) {
9237       {
9238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9239       };
9240     } catch (...) {
9241       {
9242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9243       };
9244     }
9245   }
9246
9247   jresult = result;
9248   return jresult;
9249 }
9250
9251
9252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9254   uint16_t arg2 ;
9255
9256   arg1 = (Dali::Uint16Pair *)jarg1;
9257   arg2 = (uint16_t)jarg2;
9258   {
9259     try {
9260       (arg1)->SetY(arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9268       };
9269     } catch (Dali::DaliException e) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9272       };
9273     } catch (...) {
9274       {
9275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9276       };
9277     }
9278   }
9279
9280 }
9281
9282
9283 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9284   unsigned short jresult ;
9285   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9286   uint16_t result;
9287
9288   arg1 = (Dali::Uint16Pair *)jarg1;
9289   {
9290     try {
9291       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9292     } catch (std::out_of_range& e) {
9293       {
9294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9295       };
9296     } catch (std::exception& e) {
9297       {
9298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9299       };
9300     } catch (Dali::DaliException e) {
9301       {
9302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9303       };
9304     } catch (...) {
9305       {
9306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9307       };
9308     }
9309   }
9310
9311   jresult = result;
9312   return jresult;
9313 }
9314
9315
9316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9317   void * jresult ;
9318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9319   Dali::Uint16Pair *arg2 = 0 ;
9320   Dali::Uint16Pair *result = 0 ;
9321
9322   arg1 = (Dali::Uint16Pair *)jarg1;
9323   arg2 = (Dali::Uint16Pair *)jarg2;
9324   if (!arg2) {
9325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9326     return 0;
9327   }
9328   {
9329     try {
9330       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9331     } catch (std::out_of_range& e) {
9332       {
9333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (std::exception& e) {
9336       {
9337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9338       };
9339     } catch (Dali::DaliException e) {
9340       {
9341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9342       };
9343     } catch (...) {
9344       {
9345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9346       };
9347     }
9348   }
9349
9350   jresult = (void *)result;
9351   return jresult;
9352 }
9353
9354
9355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9356   unsigned int jresult ;
9357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9358   Dali::Uint16Pair *arg2 = 0 ;
9359   bool result;
9360
9361   arg1 = (Dali::Uint16Pair *)jarg1;
9362   arg2 = (Dali::Uint16Pair *)jarg2;
9363   if (!arg2) {
9364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9365     return 0;
9366   }
9367   {
9368     try {
9369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9370     } catch (std::out_of_range& e) {
9371       {
9372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (std::exception& e) {
9375       {
9376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9377       };
9378     } catch (Dali::DaliException e) {
9379       {
9380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9381       };
9382     } catch (...) {
9383       {
9384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9385       };
9386     }
9387   }
9388
9389   jresult = result;
9390   return jresult;
9391 }
9392
9393
9394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9395   unsigned int jresult ;
9396   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9397   Dali::Uint16Pair *arg2 = 0 ;
9398   bool result;
9399
9400   arg1 = (Dali::Uint16Pair *)jarg1;
9401   arg2 = (Dali::Uint16Pair *)jarg2;
9402   if (!arg2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9404     return 0;
9405   }
9406   {
9407     try {
9408       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9409     } catch (std::out_of_range& e) {
9410       {
9411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9412       };
9413     } catch (std::exception& e) {
9414       {
9415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9416       };
9417     } catch (Dali::DaliException e) {
9418       {
9419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9420       };
9421     } catch (...) {
9422       {
9423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9424       };
9425     }
9426   }
9427
9428   jresult = result;
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9434   unsigned int jresult ;
9435   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9436   Dali::Uint16Pair *arg2 = 0 ;
9437   bool result;
9438
9439   arg1 = (Dali::Uint16Pair *)jarg1;
9440   arg2 = (Dali::Uint16Pair *)jarg2;
9441   if (!arg2) {
9442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9443     return 0;
9444   }
9445   {
9446     try {
9447       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9448     } catch (std::out_of_range& e) {
9449       {
9450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9451       };
9452     } catch (std::exception& e) {
9453       {
9454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (Dali::DaliException e) {
9457       {
9458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9475   Dali::Uint16Pair *arg2 = 0 ;
9476   bool result;
9477
9478   arg1 = (Dali::Uint16Pair *)jarg1;
9479   arg2 = (Dali::Uint16Pair *)jarg2;
9480   if (!arg2) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9482     return 0;
9483   }
9484   {
9485     try {
9486       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9487     } catch (std::out_of_range& e) {
9488       {
9489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9490       };
9491     } catch (std::exception& e) {
9492       {
9493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9494       };
9495     } catch (Dali::DaliException e) {
9496       {
9497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9498       };
9499     } catch (...) {
9500       {
9501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9502       };
9503     }
9504   }
9505
9506   jresult = result;
9507   return jresult;
9508 }
9509
9510
9511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9512   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9513
9514   arg1 = (Dali::Uint16Pair *)jarg1;
9515   {
9516     try {
9517       delete arg1;
9518     } catch (std::out_of_range& e) {
9519       {
9520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9521       };
9522     } catch (std::exception& e) {
9523       {
9524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9525       };
9526     } catch (Dali::DaliException e) {
9527       {
9528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9529       };
9530     } catch (...) {
9531       {
9532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9533       };
9534     }
9535   }
9536
9537 }
9538
9539
9540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9541   void * jresult ;
9542   Dali::Degree *result = 0 ;
9543
9544   {
9545     try {
9546       result = (Dali::Degree *)new Dali::Degree();
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (Dali::DaliException e) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9558       };
9559     } catch (...) {
9560       {
9561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9562       };
9563     }
9564   }
9565
9566   jresult = (void *)result;
9567   return jresult;
9568 }
9569
9570
9571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9572   void * jresult ;
9573   float arg1 ;
9574   Dali::Degree *result = 0 ;
9575
9576   arg1 = (float)jarg1;
9577   {
9578     try {
9579       result = (Dali::Degree *)new Dali::Degree(arg1);
9580     } catch (std::out_of_range& e) {
9581       {
9582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (std::exception& e) {
9585       {
9586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9587       };
9588     } catch (Dali::DaliException e) {
9589       {
9590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9591       };
9592     } catch (...) {
9593       {
9594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9595       };
9596     }
9597   }
9598
9599   jresult = (void *)result;
9600   return jresult;
9601 }
9602
9603
9604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9605   void * jresult ;
9606   Dali::Radian arg1 ;
9607   Dali::Radian *argp1 ;
9608   Dali::Degree *result = 0 ;
9609
9610   argp1 = (Dali::Radian *)jarg1;
9611   if (!argp1) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9613     return 0;
9614   }
9615   arg1 = *argp1;
9616   {
9617     try {
9618       result = (Dali::Degree *)new Dali::Degree(arg1);
9619     } catch (std::out_of_range& e) {
9620       {
9621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (std::exception& e) {
9624       {
9625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9626       };
9627     } catch (Dali::DaliException e) {
9628       {
9629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9630       };
9631     } catch (...) {
9632       {
9633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9634       };
9635     }
9636   }
9637
9638   jresult = (void *)result;
9639   return jresult;
9640 }
9641
9642
9643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9644   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9645   float arg2 ;
9646
9647   arg1 = (Dali::Degree *)jarg1;
9648   arg2 = (float)jarg2;
9649   if (arg1) (arg1)->degree = arg2;
9650 }
9651
9652
9653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9654   float jresult ;
9655   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9656   float result;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   result = (float) ((arg1)->degree);
9660   jresult = result;
9661   return jresult;
9662 }
9663
9664
9665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9666   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9667
9668   arg1 = (Dali::Degree *)jarg1;
9669   {
9670     try {
9671       delete arg1;
9672     } catch (std::out_of_range& e) {
9673       {
9674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9675       };
9676     } catch (std::exception& e) {
9677       {
9678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9679       };
9680     } catch (Dali::DaliException e) {
9681       {
9682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9683       };
9684     } catch (...) {
9685       {
9686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9687       };
9688     }
9689   }
9690
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_360;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_315;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_270;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_225;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_180;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_135;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_120;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_90;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_60;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_45;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_30;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9805   void * jresult ;
9806   Dali::Radian *result = 0 ;
9807
9808   result = (Dali::Radian *)&Dali::ANGLE_0;
9809   jresult = (void *)result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9815   unsigned int jresult ;
9816   Dali::Degree *arg1 = 0 ;
9817   Dali::Degree *arg2 = 0 ;
9818   bool result;
9819
9820   arg1 = (Dali::Degree *)jarg1;
9821   if (!arg1) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   arg2 = (Dali::Degree *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9828     return 0;
9829   }
9830   {
9831     try {
9832       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9833     } catch (std::out_of_range& e) {
9834       {
9835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (std::exception& e) {
9838       {
9839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (Dali::DaliException e) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9858   unsigned int jresult ;
9859   Dali::Degree *arg1 = 0 ;
9860   Dali::Degree *arg2 = 0 ;
9861   bool result;
9862
9863   arg1 = (Dali::Degree *)jarg1;
9864   if (!arg1) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   arg2 = (Dali::Degree *)jarg2;
9869   if (!arg2) {
9870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9871     return 0;
9872   }
9873   {
9874     try {
9875       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9876     } catch (std::out_of_range& e) {
9877       {
9878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (std::exception& e) {
9881       {
9882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9883       };
9884     } catch (Dali::DaliException e) {
9885       {
9886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9887       };
9888     } catch (...) {
9889       {
9890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9891       };
9892     }
9893   }
9894
9895   jresult = result;
9896   return jresult;
9897 }
9898
9899
9900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9901   void * jresult ;
9902   Dali::Degree arg1 ;
9903   float arg2 ;
9904   float arg3 ;
9905   Dali::Degree *argp1 ;
9906   Dali::Degree result;
9907
9908   argp1 = (Dali::Degree *)jarg1;
9909   if (!argp1) {
9910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9911     return 0;
9912   }
9913   arg1 = *argp1;
9914   arg2 = (float)jarg2;
9915   arg3 = (float)jarg3;
9916   {
9917     try {
9918       result = Dali::Clamp(arg1,arg2,arg3);
9919     } catch (std::out_of_range& e) {
9920       {
9921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (std::exception& e) {
9924       {
9925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (Dali::DaliException e) {
9928       {
9929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937
9938   jresult = new Dali::Degree((const Dali::Degree &)result);
9939   return jresult;
9940 }
9941
9942
9943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9944   void * jresult ;
9945   Dali::Radian *result = 0 ;
9946
9947   {
9948     try {
9949       result = (Dali::Radian *)new Dali::Radian();
9950     } catch (std::out_of_range& e) {
9951       {
9952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9953       };
9954     } catch (std::exception& e) {
9955       {
9956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9957       };
9958     } catch (Dali::DaliException e) {
9959       {
9960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9961       };
9962     } catch (...) {
9963       {
9964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9965       };
9966     }
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9975   void * jresult ;
9976   float arg1 ;
9977   Dali::Radian *result = 0 ;
9978
9979   arg1 = (float)jarg1;
9980   {
9981     try {
9982       result = (Dali::Radian *)new Dali::Radian(arg1);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (Dali::DaliException e) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9994       };
9995     } catch (...) {
9996       {
9997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9998       };
9999     }
10000   }
10001
10002   jresult = (void *)result;
10003   return jresult;
10004 }
10005
10006
10007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10008   void * jresult ;
10009   Dali::Degree arg1 ;
10010   Dali::Degree *argp1 ;
10011   Dali::Radian *result = 0 ;
10012
10013   argp1 = (Dali::Degree *)jarg1;
10014   if (!argp1) {
10015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10016     return 0;
10017   }
10018   arg1 = *argp1;
10019   {
10020     try {
10021       result = (Dali::Radian *)new Dali::Radian(arg1);
10022     } catch (std::out_of_range& e) {
10023       {
10024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10025       };
10026     } catch (std::exception& e) {
10027       {
10028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (Dali::DaliException e) {
10031       {
10032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10033       };
10034     } catch (...) {
10035       {
10036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10037       };
10038     }
10039   }
10040
10041   jresult = (void *)result;
10042   return jresult;
10043 }
10044
10045
10046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10047   void * jresult ;
10048   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10049   float arg2 ;
10050   Dali::Radian *result = 0 ;
10051
10052   arg1 = (Dali::Radian *)jarg1;
10053   arg2 = (float)jarg2;
10054   {
10055     try {
10056       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10057     } catch (std::out_of_range& e) {
10058       {
10059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (std::exception& e) {
10062       {
10063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10064       };
10065     } catch (Dali::DaliException e) {
10066       {
10067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10068       };
10069     } catch (...) {
10070       {
10071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10072       };
10073     }
10074   }
10075
10076   jresult = (void *)result;
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10082   void * jresult ;
10083   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10084   Dali::Degree arg2 ;
10085   Dali::Degree *argp2 ;
10086   Dali::Radian *result = 0 ;
10087
10088   arg1 = (Dali::Radian *)jarg1;
10089   argp2 = (Dali::Degree *)jarg2;
10090   if (!argp2) {
10091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10092     return 0;
10093   }
10094   arg2 = *argp2;
10095   {
10096     try {
10097       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10098     } catch (std::out_of_range& e) {
10099       {
10100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10101       };
10102     } catch (std::exception& e) {
10103       {
10104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10105       };
10106     } catch (Dali::DaliException e) {
10107       {
10108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10109       };
10110     } catch (...) {
10111       {
10112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10113       };
10114     }
10115   }
10116
10117   jresult = (void *)result;
10118   return jresult;
10119 }
10120
10121
10122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10123   float jresult ;
10124   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10125   float result;
10126
10127   arg1 = (Dali::Radian *)jarg1;
10128   {
10129     try {
10130       result = (float)((Dali::Radian const *)arg1)->operator float();
10131     } catch (std::out_of_range& e) {
10132       {
10133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10134       };
10135     } catch (std::exception& e) {
10136       {
10137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10138       };
10139     } catch (Dali::DaliException e) {
10140       {
10141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10142       };
10143     } catch (...) {
10144       {
10145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10146       };
10147     }
10148   }
10149
10150   jresult = result;
10151   return jresult;
10152 }
10153
10154
10155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10156   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10157   float arg2 ;
10158
10159   arg1 = (Dali::Radian *)jarg1;
10160   arg2 = (float)jarg2;
10161   if (arg1) (arg1)->radian = arg2;
10162 }
10163
10164
10165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10166   float jresult ;
10167   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10168   float result;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   result = (float) ((arg1)->radian);
10172   jresult = result;
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10178   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10179
10180   arg1 = (Dali::Radian *)jarg1;
10181   {
10182     try {
10183       delete arg1;
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10199       };
10200     }
10201   }
10202
10203 }
10204
10205
10206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10207   unsigned int jresult ;
10208   Dali::Radian arg1 ;
10209   Dali::Radian arg2 ;
10210   Dali::Radian *argp1 ;
10211   Dali::Radian *argp2 ;
10212   bool result;
10213
10214   argp1 = (Dali::Radian *)jarg1;
10215   if (!argp1) {
10216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10217     return 0;
10218   }
10219   arg1 = *argp1;
10220   argp2 = (Dali::Radian *)jarg2;
10221   if (!argp2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg2 = *argp2;
10226   {
10227     try {
10228       result = (bool)Dali::operator ==(arg1,arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (Dali::DaliException e) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10240       };
10241     } catch (...) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10244       };
10245     }
10246   }
10247
10248   jresult = result;
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10254   unsigned int jresult ;
10255   Dali::Radian arg1 ;
10256   Dali::Radian arg2 ;
10257   Dali::Radian *argp1 ;
10258   Dali::Radian *argp2 ;
10259   bool result;
10260
10261   argp1 = (Dali::Radian *)jarg1;
10262   if (!argp1) {
10263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10264     return 0;
10265   }
10266   arg1 = *argp1;
10267   argp2 = (Dali::Radian *)jarg2;
10268   if (!argp2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10270     return 0;
10271   }
10272   arg2 = *argp2;
10273   {
10274     try {
10275       result = (bool)Dali::operator !=(arg1,arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (Dali::DaliException e) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10287       };
10288     } catch (...) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10291       };
10292     }
10293   }
10294
10295   jresult = result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Radian arg1 ;
10303   Dali::Degree arg2 ;
10304   Dali::Radian *argp1 ;
10305   Dali::Degree *argp2 ;
10306   bool result;
10307
10308   argp1 = (Dali::Radian *)jarg1;
10309   if (!argp1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10311     return 0;
10312   }
10313   arg1 = *argp1;
10314   argp2 = (Dali::Degree *)jarg2;
10315   if (!argp2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10317     return 0;
10318   }
10319   arg2 = *argp2;
10320   {
10321     try {
10322       result = (bool)Dali::operator ==(arg1,arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (Dali::DaliException e) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341
10342   jresult = result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10348   unsigned int jresult ;
10349   Dali::Radian arg1 ;
10350   Dali::Degree arg2 ;
10351   Dali::Radian *argp1 ;
10352   Dali::Degree *argp2 ;
10353   bool result;
10354
10355   argp1 = (Dali::Radian *)jarg1;
10356   if (!argp1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10358     return 0;
10359   }
10360   arg1 = *argp1;
10361   argp2 = (Dali::Degree *)jarg2;
10362   if (!argp2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10364     return 0;
10365   }
10366   arg2 = *argp2;
10367   {
10368     try {
10369       result = (bool)Dali::operator !=(arg1,arg2);
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (Dali::DaliException e) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10381       };
10382     } catch (...) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10385       };
10386     }
10387   }
10388
10389   jresult = result;
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10395   unsigned int jresult ;
10396   Dali::Degree arg1 ;
10397   Dali::Radian arg2 ;
10398   Dali::Degree *argp1 ;
10399   Dali::Radian *argp2 ;
10400   bool result;
10401
10402   argp1 = (Dali::Degree *)jarg1;
10403   if (!argp1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10405     return 0;
10406   }
10407   arg1 = *argp1;
10408   argp2 = (Dali::Radian *)jarg2;
10409   if (!argp2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10411     return 0;
10412   }
10413   arg2 = *argp2;
10414   {
10415     try {
10416       result = (bool)Dali::operator ==(arg1,arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (Dali::DaliException e) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10428       };
10429     } catch (...) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10432       };
10433     }
10434   }
10435
10436   jresult = result;
10437   return jresult;
10438 }
10439
10440
10441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10442   unsigned int jresult ;
10443   Dali::Degree arg1 ;
10444   Dali::Radian arg2 ;
10445   Dali::Degree *argp1 ;
10446   Dali::Radian *argp2 ;
10447   bool result;
10448
10449   argp1 = (Dali::Degree *)jarg1;
10450   if (!argp1) {
10451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10452     return 0;
10453   }
10454   arg1 = *argp1;
10455   argp2 = (Dali::Radian *)jarg2;
10456   if (!argp2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10458     return 0;
10459   }
10460   arg2 = *argp2;
10461   {
10462     try {
10463       result = (bool)Dali::operator !=(arg1,arg2);
10464     } catch (std::out_of_range& e) {
10465       {
10466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10467       };
10468     } catch (std::exception& e) {
10469       {
10470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (Dali::DaliException e) {
10473       {
10474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10475       };
10476     } catch (...) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10479       };
10480     }
10481   }
10482
10483   jresult = result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10489   unsigned int jresult ;
10490   Dali::Radian arg1 ;
10491   Dali::Radian arg2 ;
10492   Dali::Radian *argp1 ;
10493   Dali::Radian *argp2 ;
10494   bool result;
10495
10496   argp1 = (Dali::Radian *)jarg1;
10497   if (!argp1) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10499     return 0;
10500   }
10501   arg1 = *argp1;
10502   argp2 = (Dali::Radian *)jarg2;
10503   if (!argp2) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10505     return 0;
10506   }
10507   arg2 = *argp2;
10508   {
10509     try {
10510       result = (bool)Dali::operator >(arg1,arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (Dali::DaliException e) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10522       };
10523     } catch (...) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10526       };
10527     }
10528   }
10529
10530   jresult = result;
10531   return jresult;
10532 }
10533
10534
10535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10536   unsigned int jresult ;
10537   Dali::Radian arg1 ;
10538   Dali::Degree arg2 ;
10539   Dali::Radian *argp1 ;
10540   Dali::Degree *argp2 ;
10541   bool result;
10542
10543   argp1 = (Dali::Radian *)jarg1;
10544   if (!argp1) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10546     return 0;
10547   }
10548   arg1 = *argp1;
10549   argp2 = (Dali::Degree *)jarg2;
10550   if (!argp2) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10552     return 0;
10553   }
10554   arg2 = *argp2;
10555   {
10556     try {
10557       result = (bool)Dali::operator >(arg1,arg2);
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (Dali::DaliException e) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10569       };
10570     } catch (...) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10573       };
10574     }
10575   }
10576
10577   jresult = result;
10578   return jresult;
10579 }
10580
10581
10582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10583   unsigned int jresult ;
10584   Dali::Degree arg1 ;
10585   Dali::Radian arg2 ;
10586   Dali::Degree *argp1 ;
10587   Dali::Radian *argp2 ;
10588   bool result;
10589
10590   argp1 = (Dali::Degree *)jarg1;
10591   if (!argp1) {
10592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10593     return 0;
10594   }
10595   arg1 = *argp1;
10596   argp2 = (Dali::Radian *)jarg2;
10597   if (!argp2) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10599     return 0;
10600   }
10601   arg2 = *argp2;
10602   {
10603     try {
10604       result = (bool)Dali::operator >(arg1,arg2);
10605     } catch (std::out_of_range& e) {
10606       {
10607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (std::exception& e) {
10610       {
10611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (Dali::DaliException e) {
10614       {
10615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623
10624   jresult = result;
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10630   unsigned int jresult ;
10631   Dali::Radian arg1 ;
10632   Dali::Radian arg2 ;
10633   Dali::Radian *argp1 ;
10634   Dali::Radian *argp2 ;
10635   bool result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   argp2 = (Dali::Radian *)jarg2;
10644   if (!argp2) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10646     return 0;
10647   }
10648   arg2 = *argp2;
10649   {
10650     try {
10651       result = (bool)Dali::operator <(arg1,arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (Dali::DaliException e) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670
10671   jresult = result;
10672   return jresult;
10673 }
10674
10675
10676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10677   unsigned int jresult ;
10678   Dali::Radian arg1 ;
10679   Dali::Degree arg2 ;
10680   Dali::Radian *argp1 ;
10681   Dali::Degree *argp2 ;
10682   bool result;
10683
10684   argp1 = (Dali::Radian *)jarg1;
10685   if (!argp1) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10687     return 0;
10688   }
10689   arg1 = *argp1;
10690   argp2 = (Dali::Degree *)jarg2;
10691   if (!argp2) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10693     return 0;
10694   }
10695   arg2 = *argp2;
10696   {
10697     try {
10698       result = (bool)Dali::operator <(arg1,arg2);
10699     } catch (std::out_of_range& e) {
10700       {
10701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (std::exception& e) {
10704       {
10705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10706       };
10707     } catch (Dali::DaliException e) {
10708       {
10709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10710       };
10711     } catch (...) {
10712       {
10713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10714       };
10715     }
10716   }
10717
10718   jresult = result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10724   unsigned int jresult ;
10725   Dali::Degree arg1 ;
10726   Dali::Radian arg2 ;
10727   Dali::Degree *argp1 ;
10728   Dali::Radian *argp2 ;
10729   bool result;
10730
10731   argp1 = (Dali::Degree *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   argp2 = (Dali::Radian *)jarg2;
10738   if (!argp2) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10740     return 0;
10741   }
10742   arg2 = *argp2;
10743   {
10744     try {
10745       result = (bool)Dali::operator <(arg1,arg2);
10746     } catch (std::out_of_range& e) {
10747       {
10748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (std::exception& e) {
10751       {
10752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10753       };
10754     } catch (Dali::DaliException e) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10757       };
10758     } catch (...) {
10759       {
10760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10761       };
10762     }
10763   }
10764
10765   jresult = result;
10766   return jresult;
10767 }
10768
10769
10770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10771   void * jresult ;
10772   Dali::Radian arg1 ;
10773   float arg2 ;
10774   Dali::Radian *argp1 ;
10775   Dali::Radian result;
10776
10777   argp1 = (Dali::Radian *)jarg1;
10778   if (!argp1) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10780     return 0;
10781   }
10782   arg1 = *argp1;
10783   arg2 = (float)jarg2;
10784   {
10785     try {
10786       result = Dali::operator *(arg1,arg2);
10787     } catch (std::out_of_range& e) {
10788       {
10789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10790       };
10791     } catch (std::exception& e) {
10792       {
10793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10794       };
10795     } catch (Dali::DaliException e) {
10796       {
10797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10798       };
10799     } catch (...) {
10800       {
10801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10802       };
10803     }
10804   }
10805
10806   jresult = new Dali::Radian((const Dali::Radian &)result);
10807   return jresult;
10808 }
10809
10810
10811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10812   void * jresult ;
10813   Dali::Radian arg1 ;
10814   Dali::Radian *argp1 ;
10815   Dali::Radian result;
10816
10817   argp1 = (Dali::Radian *)jarg1;
10818   if (!argp1) {
10819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10820     return 0;
10821   }
10822   arg1 = *argp1;
10823   {
10824     try {
10825       result = Dali::operator -(arg1);
10826     } catch (std::out_of_range& e) {
10827       {
10828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10829       };
10830     } catch (std::exception& e) {
10831       {
10832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10833       };
10834     } catch (Dali::DaliException e) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10837       };
10838     } catch (...) {
10839       {
10840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10841       };
10842     }
10843   }
10844
10845   jresult = new Dali::Radian((const Dali::Radian &)result);
10846   return jresult;
10847 }
10848
10849
10850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10851   void * jresult ;
10852   Dali::Radian arg1 ;
10853   float arg2 ;
10854   float arg3 ;
10855   Dali::Radian *argp1 ;
10856   Dali::Radian result;
10857
10858   argp1 = (Dali::Radian *)jarg1;
10859   if (!argp1) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10861     return 0;
10862   }
10863   arg1 = *argp1;
10864   arg2 = (float)jarg2;
10865   arg3 = (float)jarg3;
10866   {
10867     try {
10868       result = Dali::Clamp(arg1,arg2,arg3);
10869     } catch (std::out_of_range& e) {
10870       {
10871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (std::exception& e) {
10874       {
10875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10876       };
10877     } catch (Dali::DaliException e) {
10878       {
10879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10880       };
10881     } catch (...) {
10882       {
10883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10884       };
10885     }
10886   }
10887
10888   jresult = new Dali::Radian((const Dali::Radian &)result);
10889   return jresult;
10890 }
10891
10892
10893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10894   void * jresult ;
10895   Dali::Quaternion *result = 0 ;
10896
10897   {
10898     try {
10899       result = (Dali::Quaternion *)new Dali::Quaternion();
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (Dali::DaliException e) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10911       };
10912     } catch (...) {
10913       {
10914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10915       };
10916     }
10917   }
10918
10919   jresult = (void *)result;
10920   return jresult;
10921 }
10922
10923
10924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10925   void * jresult ;
10926   Dali::Radian arg1 ;
10927   Dali::Vector3 *arg2 = 0 ;
10928   Dali::Radian *argp1 ;
10929   Dali::Quaternion *result = 0 ;
10930
10931   argp1 = (Dali::Radian *)jarg1;
10932   if (!argp1) {
10933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10934     return 0;
10935   }
10936   arg1 = *argp1;
10937   arg2 = (Dali::Vector3 *)jarg2;
10938   if (!arg2) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10940     return 0;
10941   }
10942   {
10943     try {
10944       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (Dali::DaliException e) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10956       };
10957     } catch (...) {
10958       {
10959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10960       };
10961     }
10962   }
10963
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10971
10972   arg1 = (Dali::Quaternion *)jarg1;
10973   {
10974     try {
10975       delete arg1;
10976     } catch (std::out_of_range& e) {
10977       {
10978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10979       };
10980     } catch (std::exception& e) {
10981       {
10982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10983       };
10984     } catch (Dali::DaliException e) {
10985       {
10986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10987       };
10988     } catch (...) {
10989       {
10990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10991       };
10992     }
10993   }
10994
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10999   void * jresult ;
11000   Dali::Quaternion *result = 0 ;
11001
11002   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11003   jresult = (void *)result;
11004   return jresult;
11005 }
11006
11007
11008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11009   unsigned int jresult ;
11010   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11011   bool result;
11012
11013   arg1 = (Dali::Quaternion *)jarg1;
11014   {
11015     try {
11016       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11017     } catch (std::out_of_range& e) {
11018       {
11019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11020       };
11021     } catch (std::exception& e) {
11022       {
11023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11024       };
11025     } catch (Dali::DaliException e) {
11026       {
11027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11032       };
11033     }
11034   }
11035
11036   jresult = result;
11037   return jresult;
11038 }
11039
11040
11041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11042   unsigned int jresult ;
11043   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11044   Dali::Vector3 *arg2 = 0 ;
11045   Dali::Radian *arg3 = 0 ;
11046   bool result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Vector3 *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11052     return 0;
11053   }
11054   arg3 = (Dali::Radian *)jarg3;
11055   if (!arg3) {
11056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11057     return 0;
11058   }
11059   {
11060     try {
11061       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11062     } catch (std::out_of_range& e) {
11063       {
11064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11065       };
11066     } catch (std::exception& e) {
11067       {
11068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11069       };
11070     } catch (Dali::DaliException e) {
11071       {
11072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11077       };
11078     }
11079   }
11080
11081   jresult = result;
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11087   void * jresult ;
11088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11089   Dali::Quaternion *arg2 = 0 ;
11090   Dali::Quaternion result;
11091
11092   arg1 = (Dali::Quaternion *)jarg1;
11093   arg2 = (Dali::Quaternion *)jarg2;
11094   if (!arg2) {
11095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11096     return 0;
11097   }
11098   {
11099     try {
11100       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11108       };
11109     } catch (Dali::DaliException e) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11112       };
11113     } catch (...) {
11114       {
11115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11116       };
11117     }
11118   }
11119
11120   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11126   void * jresult ;
11127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11128   Dali::Quaternion *arg2 = 0 ;
11129   Dali::Quaternion result;
11130
11131   arg1 = (Dali::Quaternion *)jarg1;
11132   arg2 = (Dali::Quaternion *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11135     return 0;
11136   }
11137   {
11138     try {
11139       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (Dali::DaliException e) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11155       };
11156     }
11157   }
11158
11159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11160   return jresult;
11161 }
11162
11163
11164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11165   void * jresult ;
11166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11167   Dali::Quaternion *arg2 = 0 ;
11168   Dali::Quaternion result;
11169
11170   arg1 = (Dali::Quaternion *)jarg1;
11171   arg2 = (Dali::Quaternion *)jarg2;
11172   if (!arg2) {
11173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11174     return 0;
11175   }
11176   {
11177     try {
11178       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11179     } catch (std::out_of_range& e) {
11180       {
11181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11182       };
11183     } catch (std::exception& e) {
11184       {
11185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (Dali::DaliException e) {
11188       {
11189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197
11198   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11199   return jresult;
11200 }
11201
11202
11203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11204   void * jresult ;
11205   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11206   Dali::Vector3 *arg2 = 0 ;
11207   Dali::Vector3 result;
11208
11209   arg1 = (Dali::Quaternion *)jarg1;
11210   arg2 = (Dali::Vector3 *)jarg2;
11211   if (!arg2) {
11212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11213     return 0;
11214   }
11215   {
11216     try {
11217       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (Dali::DaliException e) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236
11237   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11243   void * jresult ;
11244   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11245   Dali::Quaternion *arg2 = 0 ;
11246   Dali::Quaternion result;
11247
11248   arg1 = (Dali::Quaternion *)jarg1;
11249   arg2 = (Dali::Quaternion *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11252     return 0;
11253   }
11254   {
11255     try {
11256       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11257     } catch (std::out_of_range& e) {
11258       {
11259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11260       };
11261     } catch (std::exception& e) {
11262       {
11263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11264       };
11265     } catch (Dali::DaliException e) {
11266       {
11267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11268       };
11269     } catch (...) {
11270       {
11271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11272       };
11273     }
11274   }
11275
11276   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11277   return jresult;
11278 }
11279
11280
11281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11282   void * jresult ;
11283   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11284   float arg2 ;
11285   Dali::Quaternion result;
11286
11287   arg1 = (Dali::Quaternion *)jarg1;
11288   arg2 = (float)jarg2;
11289   {
11290     try {
11291       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11292     } catch (std::out_of_range& e) {
11293       {
11294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11295       };
11296     } catch (std::exception& e) {
11297       {
11298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11299       };
11300     } catch (Dali::DaliException e) {
11301       {
11302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11303       };
11304     } catch (...) {
11305       {
11306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11307       };
11308     }
11309   }
11310
11311   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11317   void * jresult ;
11318   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11319   float arg2 ;
11320   Dali::Quaternion result;
11321
11322   arg1 = (Dali::Quaternion *)jarg1;
11323   arg2 = (float)jarg2;
11324   {
11325     try {
11326       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11327     } catch (std::out_of_range& e) {
11328       {
11329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11330       };
11331     } catch (std::exception& e) {
11332       {
11333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11334       };
11335     } catch (Dali::DaliException e) {
11336       {
11337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11338       };
11339     } catch (...) {
11340       {
11341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11342       };
11343     }
11344   }
11345
11346   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11352   void * jresult ;
11353   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11354   Dali::Quaternion result;
11355
11356   arg1 = (Dali::Quaternion *)jarg1;
11357   {
11358     try {
11359       result = ((Dali::Quaternion const *)arg1)->operator -();
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11367       };
11368     } catch (Dali::DaliException e) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11371       };
11372     } catch (...) {
11373       {
11374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11375       };
11376     }
11377   }
11378
11379   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11380   return jresult;
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11385   void * jresult ;
11386   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11387   Dali::Quaternion *arg2 = 0 ;
11388   Dali::Quaternion *result = 0 ;
11389
11390   arg1 = (Dali::Quaternion *)jarg1;
11391   arg2 = (Dali::Quaternion *)jarg2;
11392   if (!arg2) {
11393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11394     return 0;
11395   }
11396   {
11397     try {
11398       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11399     } catch (std::out_of_range& e) {
11400       {
11401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11402       };
11403     } catch (std::exception& e) {
11404       {
11405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11406       };
11407     } catch (Dali::DaliException e) {
11408       {
11409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11410       };
11411     } catch (...) {
11412       {
11413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11414       };
11415     }
11416   }
11417
11418   jresult = (void *)result;
11419   return jresult;
11420 }
11421
11422
11423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11424   void * jresult ;
11425   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11426   Dali::Quaternion *arg2 = 0 ;
11427   Dali::Quaternion *result = 0 ;
11428
11429   arg1 = (Dali::Quaternion *)jarg1;
11430   arg2 = (Dali::Quaternion *)jarg2;
11431   if (!arg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11433     return 0;
11434   }
11435   {
11436     try {
11437       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11438     } catch (std::out_of_range& e) {
11439       {
11440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11441       };
11442     } catch (std::exception& e) {
11443       {
11444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11445       };
11446     } catch (Dali::DaliException e) {
11447       {
11448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11449       };
11450     } catch (...) {
11451       {
11452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11453       };
11454     }
11455   }
11456
11457   jresult = (void *)result;
11458   return jresult;
11459 }
11460
11461
11462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11463   void * jresult ;
11464   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11465   Dali::Quaternion *arg2 = 0 ;
11466   Dali::Quaternion *result = 0 ;
11467
11468   arg1 = (Dali::Quaternion *)jarg1;
11469   arg2 = (Dali::Quaternion *)jarg2;
11470   if (!arg2) {
11471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11472     return 0;
11473   }
11474   {
11475     try {
11476       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11477     } catch (std::out_of_range& e) {
11478       {
11479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (std::exception& e) {
11482       {
11483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11484       };
11485     } catch (Dali::DaliException e) {
11486       {
11487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11488       };
11489     } catch (...) {
11490       {
11491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11492       };
11493     }
11494   }
11495
11496   jresult = (void *)result;
11497   return jresult;
11498 }
11499
11500
11501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11502   void * jresult ;
11503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11504   float arg2 ;
11505   Dali::Quaternion *result = 0 ;
11506
11507   arg1 = (Dali::Quaternion *)jarg1;
11508   arg2 = (float)jarg2;
11509   {
11510     try {
11511       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11512     } catch (std::out_of_range& e) {
11513       {
11514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11515       };
11516     } catch (std::exception& e) {
11517       {
11518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (Dali::DaliException e) {
11521       {
11522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11527       };
11528     }
11529   }
11530
11531   jresult = (void *)result;
11532   return jresult;
11533 }
11534
11535
11536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11537   void * jresult ;
11538   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11539   float arg2 ;
11540   Dali::Quaternion *result = 0 ;
11541
11542   arg1 = (Dali::Quaternion *)jarg1;
11543   arg2 = (float)jarg2;
11544   {
11545     try {
11546       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11547     } catch (std::out_of_range& e) {
11548       {
11549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11550       };
11551     } catch (std::exception& e) {
11552       {
11553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (Dali::DaliException e) {
11556       {
11557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11558       };
11559     } catch (...) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11562       };
11563     }
11564   }
11565
11566   jresult = (void *)result;
11567   return jresult;
11568 }
11569
11570
11571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11572   unsigned int jresult ;
11573   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11574   Dali::Quaternion *arg2 = 0 ;
11575   bool result;
11576
11577   arg1 = (Dali::Quaternion *)jarg1;
11578   arg2 = (Dali::Quaternion *)jarg2;
11579   if (!arg2) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11581     return 0;
11582   }
11583   {
11584     try {
11585       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11586     } catch (std::out_of_range& e) {
11587       {
11588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11589       };
11590     } catch (std::exception& e) {
11591       {
11592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11593       };
11594     } catch (Dali::DaliException e) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11597       };
11598     } catch (...) {
11599       {
11600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11601       };
11602     }
11603   }
11604
11605   jresult = result;
11606   return jresult;
11607 }
11608
11609
11610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11611   unsigned int jresult ;
11612   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11613   Dali::Quaternion *arg2 = 0 ;
11614   bool result;
11615
11616   arg1 = (Dali::Quaternion *)jarg1;
11617   arg2 = (Dali::Quaternion *)jarg2;
11618   if (!arg2) {
11619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11620     return 0;
11621   }
11622   {
11623     try {
11624       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11625     } catch (std::out_of_range& e) {
11626       {
11627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (std::exception& e) {
11630       {
11631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11632       };
11633     } catch (Dali::DaliException e) {
11634       {
11635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11636       };
11637     } catch (...) {
11638       {
11639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11640       };
11641     }
11642   }
11643
11644   jresult = result;
11645   return jresult;
11646 }
11647
11648
11649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11650   float jresult ;
11651   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11652   float result;
11653
11654   arg1 = (Dali::Quaternion *)jarg1;
11655   {
11656     try {
11657       result = (float)((Dali::Quaternion const *)arg1)->Length();
11658     } catch (std::out_of_range& e) {
11659       {
11660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (std::exception& e) {
11663       {
11664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11665       };
11666     } catch (Dali::DaliException e) {
11667       {
11668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11669       };
11670     } catch (...) {
11671       {
11672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11673       };
11674     }
11675   }
11676
11677   jresult = result;
11678   return jresult;
11679 }
11680
11681
11682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11683   float jresult ;
11684   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11685   float result;
11686
11687   arg1 = (Dali::Quaternion *)jarg1;
11688   {
11689     try {
11690       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11691     } catch (std::out_of_range& e) {
11692       {
11693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11694       };
11695     } catch (std::exception& e) {
11696       {
11697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11698       };
11699     } catch (Dali::DaliException e) {
11700       {
11701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11702       };
11703     } catch (...) {
11704       {
11705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11706       };
11707     }
11708   }
11709
11710   jresult = result;
11711   return jresult;
11712 }
11713
11714
11715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717
11718   arg1 = (Dali::Quaternion *)jarg1;
11719   {
11720     try {
11721       (arg1)->Normalize();
11722     } catch (std::out_of_range& e) {
11723       {
11724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (std::exception& e) {
11727       {
11728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11729       };
11730     } catch (Dali::DaliException e) {
11731       {
11732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11733       };
11734     } catch (...) {
11735       {
11736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11737       };
11738     }
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11745   void * jresult ;
11746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11747   Dali::Quaternion result;
11748
11749   arg1 = (Dali::Quaternion *)jarg1;
11750   {
11751     try {
11752       result = ((Dali::Quaternion const *)arg1)->Normalized();
11753     } catch (std::out_of_range& e) {
11754       {
11755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11756       };
11757     } catch (std::exception& e) {
11758       {
11759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11760       };
11761     } catch (Dali::DaliException e) {
11762       {
11763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11764       };
11765     } catch (...) {
11766       {
11767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11768       };
11769     }
11770   }
11771
11772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11773   return jresult;
11774 }
11775
11776
11777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11778   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11779
11780   arg1 = (Dali::Quaternion *)jarg1;
11781   {
11782     try {
11783       (arg1)->Conjugate();
11784     } catch (std::out_of_range& e) {
11785       {
11786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11787       };
11788     } catch (std::exception& e) {
11789       {
11790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11791       };
11792     } catch (Dali::DaliException e) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11795       };
11796     } catch (...) {
11797       {
11798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11799       };
11800     }
11801   }
11802
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808
11809   arg1 = (Dali::Quaternion *)jarg1;
11810   {
11811     try {
11812       (arg1)->Invert();
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (Dali::DaliException e) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11824       };
11825     } catch (...) {
11826       {
11827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11828       };
11829     }
11830   }
11831
11832 }
11833
11834
11835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11836   void * jresult ;
11837   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11838   Dali::Quaternion result;
11839
11840   arg1 = (Dali::Quaternion *)jarg1;
11841   {
11842     try {
11843       result = ((Dali::Quaternion const *)arg1)->Log();
11844     } catch (std::out_of_range& e) {
11845       {
11846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11847       };
11848     } catch (std::exception& e) {
11849       {
11850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11851       };
11852     } catch (Dali::DaliException e) {
11853       {
11854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11855       };
11856     } catch (...) {
11857       {
11858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11859       };
11860     }
11861   }
11862
11863   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11864   return jresult;
11865 }
11866
11867
11868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11869   void * jresult ;
11870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11871   Dali::Quaternion result;
11872
11873   arg1 = (Dali::Quaternion *)jarg1;
11874   {
11875     try {
11876       result = ((Dali::Quaternion const *)arg1)->Exp();
11877     } catch (std::out_of_range& e) {
11878       {
11879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (std::exception& e) {
11882       {
11883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11884       };
11885     } catch (Dali::DaliException e) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11888       };
11889     } catch (...) {
11890       {
11891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11892       };
11893     }
11894   }
11895
11896   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11897   return jresult;
11898 }
11899
11900
11901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11902   float jresult ;
11903   Dali::Quaternion *arg1 = 0 ;
11904   Dali::Quaternion *arg2 = 0 ;
11905   float result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   {
11918     try {
11919       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (Dali::DaliException e) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11931       };
11932     } catch (...) {
11933       {
11934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11935       };
11936     }
11937   }
11938
11939   jresult = result;
11940   return jresult;
11941 }
11942
11943
11944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11945   void * jresult ;
11946   Dali::Quaternion *arg1 = 0 ;
11947   Dali::Quaternion *arg2 = 0 ;
11948   float arg3 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (float)jarg3;
11962   {
11963     try {
11964       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (Dali::DaliException e) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983
11984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11990   void * jresult ;
11991   Dali::Quaternion *arg1 = 0 ;
11992   Dali::Quaternion *arg2 = 0 ;
11993   float arg3 ;
11994   Dali::Quaternion result;
11995
11996   arg1 = (Dali::Quaternion *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg2 = (Dali::Quaternion *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12004     return 0;
12005   }
12006   arg3 = (float)jarg3;
12007   {
12008     try {
12009       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12010     } catch (std::out_of_range& e) {
12011       {
12012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12013       };
12014     } catch (std::exception& e) {
12015       {
12016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (Dali::DaliException e) {
12019       {
12020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028
12029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12035   void * jresult ;
12036   Dali::Quaternion *arg1 = 0 ;
12037   Dali::Quaternion *arg2 = 0 ;
12038   float arg3 ;
12039   Dali::Quaternion result;
12040
12041   arg1 = (Dali::Quaternion *)jarg1;
12042   if (!arg1) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg2 = (Dali::Quaternion *)jarg2;
12047   if (!arg2) {
12048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12049     return 0;
12050   }
12051   arg3 = (float)jarg3;
12052   {
12053     try {
12054       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12055     } catch (std::out_of_range& e) {
12056       {
12057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12058       };
12059     } catch (std::exception& e) {
12060       {
12061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12062       };
12063     } catch (Dali::DaliException e) {
12064       {
12065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12066       };
12067     } catch (...) {
12068       {
12069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12070       };
12071     }
12072   }
12073
12074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12080   void * jresult ;
12081   Dali::Quaternion *arg1 = 0 ;
12082   Dali::Quaternion *arg2 = 0 ;
12083   Dali::Quaternion *arg3 = 0 ;
12084   Dali::Quaternion *arg4 = 0 ;
12085   float arg5 ;
12086   Dali::Quaternion result;
12087
12088   arg1 = (Dali::Quaternion *)jarg1;
12089   if (!arg1) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg2 = (Dali::Quaternion *)jarg2;
12094   if (!arg2) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg3 = (Dali::Quaternion *)jarg3;
12099   if (!arg3) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg4 = (Dali::Quaternion *)jarg4;
12104   if (!arg4) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   arg5 = (float)jarg5;
12109   {
12110     try {
12111       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (Dali::DaliException e) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130
12131   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12132   return jresult;
12133 }
12134
12135
12136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12137   float jresult ;
12138   Dali::Quaternion *arg1 = 0 ;
12139   Dali::Quaternion *arg2 = 0 ;
12140   float result;
12141
12142   arg1 = (Dali::Quaternion *)jarg1;
12143   if (!arg1) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   arg2 = (Dali::Quaternion *)jarg2;
12148   if (!arg2) {
12149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12150     return 0;
12151   }
12152   {
12153     try {
12154       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12155     } catch (std::out_of_range& e) {
12156       {
12157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12158       };
12159     } catch (std::exception& e) {
12160       {
12161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (Dali::DaliException e) {
12164       {
12165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173
12174   jresult = result;
12175   return jresult;
12176 }
12177
12178
12179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12180   void * jresult ;
12181   Dali::Matrix *result = 0 ;
12182
12183   {
12184     try {
12185       result = (Dali::Matrix *)new Dali::Matrix();
12186     } catch (std::out_of_range& e) {
12187       {
12188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (std::exception& e) {
12191       {
12192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12193       };
12194     } catch (Dali::DaliException e) {
12195       {
12196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12197       };
12198     } catch (...) {
12199       {
12200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12201       };
12202     }
12203   }
12204
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12211   void * jresult ;
12212   bool arg1 ;
12213   Dali::Matrix *result = 0 ;
12214
12215   arg1 = jarg1 ? true : false;
12216   {
12217     try {
12218       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (Dali::DaliException e) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12230       };
12231     } catch (...) {
12232       {
12233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12234       };
12235     }
12236   }
12237
12238   jresult = (void *)result;
12239   return jresult;
12240 }
12241
12242
12243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12244   void * jresult ;
12245   float *arg1 = (float *) 0 ;
12246   Dali::Matrix *result = 0 ;
12247
12248   arg1 = jarg1;
12249   {
12250     try {
12251       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12252     } catch (std::out_of_range& e) {
12253       {
12254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (std::exception& e) {
12257       {
12258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12259       };
12260     } catch (Dali::DaliException e) {
12261       {
12262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12263       };
12264     } catch (...) {
12265       {
12266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12267       };
12268     }
12269   }
12270
12271   jresult = (void *)result;
12272
12273
12274   return jresult;
12275 }
12276
12277
12278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12279   void * jresult ;
12280   Dali::Quaternion *arg1 = 0 ;
12281   Dali::Matrix *result = 0 ;
12282
12283   arg1 = (Dali::Quaternion *)jarg1;
12284   if (!arg1) {
12285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12286     return 0;
12287   }
12288   {
12289     try {
12290       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12291     } catch (std::out_of_range& e) {
12292       {
12293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (std::exception& e) {
12296       {
12297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12298       };
12299     } catch (Dali::DaliException e) {
12300       {
12301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12302       };
12303     } catch (...) {
12304       {
12305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12306       };
12307     }
12308   }
12309
12310   jresult = (void *)result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12316   void * jresult ;
12317   Dali::Matrix *arg1 = 0 ;
12318   Dali::Matrix *result = 0 ;
12319
12320   arg1 = (Dali::Matrix *)jarg1;
12321   if (!arg1) {
12322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12323     return 0;
12324   }
12325   {
12326     try {
12327       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (Dali::DaliException e) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12339       };
12340     } catch (...) {
12341       {
12342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12343       };
12344     }
12345   }
12346
12347   jresult = (void *)result;
12348   return jresult;
12349 }
12350
12351
12352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12353   void * jresult ;
12354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12355   Dali::Matrix *arg2 = 0 ;
12356   Dali::Matrix *result = 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   arg2 = (Dali::Matrix *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12362     return 0;
12363   }
12364   {
12365     try {
12366       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12367     } catch (std::out_of_range& e) {
12368       {
12369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12370       };
12371     } catch (std::exception& e) {
12372       {
12373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12374       };
12375     } catch (Dali::DaliException e) {
12376       {
12377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12382       };
12383     }
12384   }
12385
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12392   void * jresult ;
12393   Dali::Matrix *result = 0 ;
12394
12395   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12396   jresult = (void *)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12402   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   {
12406     try {
12407       (arg1)->SetIdentity();
12408     } catch (std::out_of_range& e) {
12409       {
12410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12411       };
12412     } catch (std::exception& e) {
12413       {
12414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12415       };
12416     } catch (Dali::DaliException e) {
12417       {
12418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12419       };
12420     } catch (...) {
12421       {
12422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12423       };
12424     }
12425   }
12426
12427 }
12428
12429
12430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12431   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12432   Dali::Vector3 *arg2 = 0 ;
12433
12434   arg1 = (Dali::Matrix *)jarg1;
12435   arg2 = (Dali::Vector3 *)jarg2;
12436   if (!arg2) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12438     return ;
12439   }
12440   {
12441     try {
12442       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12450       };
12451     } catch (Dali::DaliException e) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12454       };
12455     } catch (...) {
12456       {
12457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12458       };
12459     }
12460   }
12461
12462 }
12463
12464
12465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12467   Dali::Matrix *arg2 = 0 ;
12468
12469   arg1 = (Dali::Matrix *)jarg1;
12470   arg2 = (Dali::Matrix *)jarg2;
12471   if (!arg2) {
12472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12473     return ;
12474   }
12475   {
12476     try {
12477       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12478     } catch (std::out_of_range& e) {
12479       {
12480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12481       };
12482     } catch (std::exception& e) {
12483       {
12484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12485       };
12486     } catch (Dali::DaliException e) {
12487       {
12488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12489       };
12490     } catch (...) {
12491       {
12492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12493       };
12494     }
12495   }
12496
12497 }
12498
12499
12500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12501   unsigned int jresult ;
12502   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12503   bool result;
12504
12505   arg1 = (Dali::Matrix *)jarg1;
12506   {
12507     try {
12508       result = (bool)(arg1)->Invert();
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (Dali::DaliException e) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12520       };
12521     } catch (...) {
12522       {
12523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12524       };
12525     }
12526   }
12527
12528   jresult = result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535
12536   arg1 = (Dali::Matrix *)jarg1;
12537   {
12538     try {
12539       (arg1)->Transpose();
12540     } catch (std::out_of_range& e) {
12541       {
12542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12543       };
12544     } catch (std::exception& e) {
12545       {
12546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12547       };
12548     } catch (Dali::DaliException e) {
12549       {
12550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12551       };
12552     } catch (...) {
12553       {
12554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12555       };
12556     }
12557   }
12558
12559 }
12560
12561
12562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12563   void * jresult ;
12564   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12565   Dali::Vector3 result;
12566
12567   arg1 = (Dali::Matrix *)jarg1;
12568   {
12569     try {
12570       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12571     } catch (std::out_of_range& e) {
12572       {
12573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12574       };
12575     } catch (std::exception& e) {
12576       {
12577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12578       };
12579     } catch (Dali::DaliException e) {
12580       {
12581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12582       };
12583     } catch (...) {
12584       {
12585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12586       };
12587     }
12588   }
12589
12590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12596   void * jresult ;
12597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12598   Dali::Vector3 result;
12599
12600   arg1 = (Dali::Matrix *)jarg1;
12601   {
12602     try {
12603       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12604     } catch (std::out_of_range& e) {
12605       {
12606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12607       };
12608     } catch (std::exception& e) {
12609       {
12610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12611       };
12612     } catch (Dali::DaliException e) {
12613       {
12614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12615       };
12616     } catch (...) {
12617       {
12618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12619       };
12620     }
12621   }
12622
12623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12624   return jresult;
12625 }
12626
12627
12628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12629   void * jresult ;
12630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12631   Dali::Vector3 result;
12632
12633   arg1 = (Dali::Matrix *)jarg1;
12634   {
12635     try {
12636       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12637     } catch (std::out_of_range& e) {
12638       {
12639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12640       };
12641     } catch (std::exception& e) {
12642       {
12643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12644       };
12645     } catch (Dali::DaliException e) {
12646       {
12647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12648       };
12649     } catch (...) {
12650       {
12651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12652       };
12653     }
12654   }
12655
12656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12662   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12663   Dali::Vector3 *arg2 = 0 ;
12664
12665   arg1 = (Dali::Matrix *)jarg1;
12666   arg2 = (Dali::Vector3 *)jarg2;
12667   if (!arg2) {
12668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12669     return ;
12670   }
12671   {
12672     try {
12673       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12674     } catch (std::out_of_range& e) {
12675       {
12676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12677       };
12678     } catch (std::exception& e) {
12679       {
12680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12681       };
12682     } catch (Dali::DaliException e) {
12683       {
12684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12689       };
12690     }
12691   }
12692
12693 }
12694
12695
12696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12697   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12698   Dali::Vector3 *arg2 = 0 ;
12699
12700   arg1 = (Dali::Matrix *)jarg1;
12701   arg2 = (Dali::Vector3 *)jarg2;
12702   if (!arg2) {
12703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12704     return ;
12705   }
12706   {
12707     try {
12708       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12709     } catch (std::out_of_range& e) {
12710       {
12711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12712       };
12713     } catch (std::exception& e) {
12714       {
12715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12716       };
12717     } catch (Dali::DaliException e) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12720       };
12721     } catch (...) {
12722       {
12723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12724       };
12725     }
12726   }
12727
12728 }
12729
12730
12731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12732   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12733   Dali::Vector3 *arg2 = 0 ;
12734
12735   arg1 = (Dali::Matrix *)jarg1;
12736   arg2 = (Dali::Vector3 *)jarg2;
12737   if (!arg2) {
12738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12739     return ;
12740   }
12741   {
12742     try {
12743       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12744     } catch (std::out_of_range& e) {
12745       {
12746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12747       };
12748     } catch (std::exception& e) {
12749       {
12750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12751       };
12752     } catch (Dali::DaliException e) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12755       };
12756     } catch (...) {
12757       {
12758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12759       };
12760     }
12761   }
12762
12763 }
12764
12765
12766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12767   void * jresult ;
12768   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12769   Dali::Vector4 *result = 0 ;
12770
12771   arg1 = (Dali::Matrix *)jarg1;
12772   {
12773     try {
12774       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12775     } catch (std::out_of_range& e) {
12776       {
12777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12778       };
12779     } catch (std::exception& e) {
12780       {
12781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12782       };
12783     } catch (Dali::DaliException e) {
12784       {
12785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12786       };
12787     } catch (...) {
12788       {
12789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12790       };
12791     }
12792   }
12793
12794   jresult = (void *)result;
12795   return jresult;
12796 }
12797
12798
12799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12800   void * jresult ;
12801   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12802   Dali::Vector3 *result = 0 ;
12803
12804   arg1 = (Dali::Matrix *)jarg1;
12805   {
12806     try {
12807       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12808     } catch (std::out_of_range& e) {
12809       {
12810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (std::exception& e) {
12813       {
12814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (Dali::DaliException e) {
12817       {
12818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826
12827   jresult = (void *)result;
12828   return jresult;
12829 }
12830
12831
12832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12833   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12834   Dali::Vector4 *arg2 = 0 ;
12835
12836   arg1 = (Dali::Matrix *)jarg1;
12837   arg2 = (Dali::Vector4 *)jarg2;
12838   if (!arg2) {
12839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12840     return ;
12841   }
12842   {
12843     try {
12844       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12845     } catch (std::out_of_range& e) {
12846       {
12847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12848       };
12849     } catch (std::exception& e) {
12850       {
12851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12852       };
12853     } catch (Dali::DaliException e) {
12854       {
12855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12856       };
12857     } catch (...) {
12858       {
12859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12860       };
12861     }
12862   }
12863
12864 }
12865
12866
12867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12868   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12869   Dali::Vector3 *arg2 = 0 ;
12870
12871   arg1 = (Dali::Matrix *)jarg1;
12872   arg2 = (Dali::Vector3 *)jarg2;
12873   if (!arg2) {
12874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12875     return ;
12876   }
12877   {
12878     try {
12879       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12880     } catch (std::out_of_range& e) {
12881       {
12882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12883       };
12884     } catch (std::exception& e) {
12885       {
12886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12887       };
12888     } catch (Dali::DaliException e) {
12889       {
12890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12895       };
12896     }
12897   }
12898
12899 }
12900
12901
12902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904
12905   arg1 = (Dali::Matrix *)jarg1;
12906   {
12907     try {
12908       (arg1)->OrthoNormalize();
12909     } catch (std::out_of_range& e) {
12910       {
12911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12912       };
12913     } catch (std::exception& e) {
12914       {
12915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12916       };
12917     } catch (Dali::DaliException e) {
12918       {
12919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12924       };
12925     }
12926   }
12927
12928 }
12929
12930
12931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12932   void * jresult ;
12933   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12934   float *result = 0 ;
12935
12936   arg1 = (Dali::Matrix *)jarg1;
12937   {
12938     try {
12939       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12947       };
12948     } catch (Dali::DaliException e) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12951       };
12952     } catch (...) {
12953       {
12954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12955       };
12956     }
12957   }
12958
12959   jresult = (void *)result;
12960   return jresult;
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12965   Dali::Matrix *arg1 = 0 ;
12966   Dali::Matrix *arg2 = 0 ;
12967   Dali::Matrix *arg3 = 0 ;
12968
12969   arg1 = (Dali::Matrix *)jarg1;
12970   if (!arg1) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12972     return ;
12973   }
12974   arg2 = (Dali::Matrix *)jarg2;
12975   if (!arg2) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   arg3 = (Dali::Matrix *)jarg3;
12980   if (!arg3) {
12981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12982     return ;
12983   }
12984   {
12985     try {
12986       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12994       };
12995     } catch (Dali::DaliException e) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12998       };
12999     } catch (...) {
13000       {
13001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13002       };
13003     }
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13010   Dali::Matrix *arg1 = 0 ;
13011   Dali::Matrix *arg2 = 0 ;
13012   Dali::Quaternion *arg3 = 0 ;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   if (!arg1) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13017     return ;
13018   }
13019   arg2 = (Dali::Matrix *)jarg2;
13020   if (!arg2) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13022     return ;
13023   }
13024   arg3 = (Dali::Quaternion *)jarg3;
13025   if (!arg3) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13027     return ;
13028   }
13029   {
13030     try {
13031       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13039       };
13040     } catch (Dali::DaliException e) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13043       };
13044     } catch (...) {
13045       {
13046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13047       };
13048     }
13049   }
13050
13051 }
13052
13053
13054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13055   void * jresult ;
13056   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13057   Dali::Vector4 *arg2 = 0 ;
13058   Dali::Vector4 result;
13059
13060   arg1 = (Dali::Matrix *)jarg1;
13061   arg2 = (Dali::Vector4 *)jarg2;
13062   if (!arg2) {
13063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13064     return 0;
13065   }
13066   {
13067     try {
13068       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (Dali::DaliException e) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13080       };
13081     } catch (...) {
13082       {
13083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13084       };
13085     }
13086   }
13087
13088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13094   unsigned int jresult ;
13095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13096   Dali::Matrix *arg2 = 0 ;
13097   bool result;
13098
13099   arg1 = (Dali::Matrix *)jarg1;
13100   arg2 = (Dali::Matrix *)jarg2;
13101   if (!arg2) {
13102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13103     return 0;
13104   }
13105   {
13106     try {
13107       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13108     } catch (std::out_of_range& e) {
13109       {
13110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13111       };
13112     } catch (std::exception& e) {
13113       {
13114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13115       };
13116     } catch (Dali::DaliException e) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13119       };
13120     } catch (...) {
13121       {
13122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13123       };
13124     }
13125   }
13126
13127   jresult = result;
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13133   unsigned int jresult ;
13134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13135   Dali::Matrix *arg2 = 0 ;
13136   bool result;
13137
13138   arg1 = (Dali::Matrix *)jarg1;
13139   arg2 = (Dali::Matrix *)jarg2;
13140   if (!arg2) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13142     return 0;
13143   }
13144   {
13145     try {
13146       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13147     } catch (std::out_of_range& e) {
13148       {
13149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13150       };
13151     } catch (std::exception& e) {
13152       {
13153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13154       };
13155     } catch (Dali::DaliException e) {
13156       {
13157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13158       };
13159     } catch (...) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13162       };
13163     }
13164   }
13165
13166   jresult = result;
13167   return jresult;
13168 }
13169
13170
13171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13173   Dali::Vector3 *arg2 = 0 ;
13174   Dali::Quaternion *arg3 = 0 ;
13175   Dali::Vector3 *arg4 = 0 ;
13176
13177   arg1 = (Dali::Matrix *)jarg1;
13178   arg2 = (Dali::Vector3 *)jarg2;
13179   if (!arg2) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   arg3 = (Dali::Quaternion *)jarg3;
13184   if (!arg3) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13186     return ;
13187   }
13188   arg4 = (Dali::Vector3 *)jarg4;
13189   if (!arg4) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13191     return ;
13192   }
13193   {
13194     try {
13195       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13196     } catch (std::out_of_range& e) {
13197       {
13198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13199       };
13200     } catch (std::exception& e) {
13201       {
13202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13203       };
13204     } catch (Dali::DaliException e) {
13205       {
13206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13211       };
13212     }
13213   }
13214
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13219   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13220   Dali::Vector3 *arg2 = 0 ;
13221   Dali::Quaternion *arg3 = 0 ;
13222   Dali::Vector3 *arg4 = 0 ;
13223
13224   arg1 = (Dali::Matrix *)jarg1;
13225   arg2 = (Dali::Vector3 *)jarg2;
13226   if (!arg2) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   arg3 = (Dali::Quaternion *)jarg3;
13231   if (!arg3) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13233     return ;
13234   }
13235   arg4 = (Dali::Vector3 *)jarg4;
13236   if (!arg4) {
13237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13238     return ;
13239   }
13240   {
13241     try {
13242       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13243     } catch (std::out_of_range& e) {
13244       {
13245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13246       };
13247     } catch (std::exception& e) {
13248       {
13249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13250       };
13251     } catch (Dali::DaliException e) {
13252       {
13253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13254       };
13255     } catch (...) {
13256       {
13257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13258       };
13259     }
13260   }
13261
13262 }
13263
13264
13265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13266   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13267   Dali::Vector3 *arg2 = 0 ;
13268   Dali::Vector3 *arg3 = 0 ;
13269   Dali::Vector3 *arg4 = 0 ;
13270   Dali::Vector3 *arg5 = 0 ;
13271
13272   arg1 = (Dali::Matrix *)jarg1;
13273   arg2 = (Dali::Vector3 *)jarg2;
13274   if (!arg2) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg3 = (Dali::Vector3 *)jarg3;
13279   if (!arg3) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg4 = (Dali::Vector3 *)jarg4;
13284   if (!arg4) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   arg5 = (Dali::Vector3 *)jarg5;
13289   if (!arg5) {
13290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13291     return ;
13292   }
13293   {
13294     try {
13295       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (Dali::DaliException e) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13307       };
13308     } catch (...) {
13309       {
13310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13311       };
13312     }
13313   }
13314
13315 }
13316
13317
13318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13319   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13320   Dali::Vector3 *arg2 = 0 ;
13321   Dali::Quaternion *arg3 = 0 ;
13322   Dali::Vector3 *arg4 = 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   arg2 = (Dali::Vector3 *)jarg2;
13326   if (!arg2) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   arg3 = (Dali::Quaternion *)jarg3;
13331   if (!arg3) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13333     return ;
13334   }
13335   arg4 = (Dali::Vector3 *)jarg4;
13336   if (!arg4) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13343     } catch (std::out_of_range& e) {
13344       {
13345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13346       };
13347     } catch (std::exception& e) {
13348       {
13349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13350       };
13351     } catch (Dali::DaliException e) {
13352       {
13353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13354       };
13355     } catch (...) {
13356       {
13357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13358       };
13359     }
13360   }
13361
13362 }
13363
13364
13365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13366   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13367
13368   arg1 = (Dali::Matrix *)jarg1;
13369   {
13370     try {
13371       delete arg1;
13372     } catch (std::out_of_range& e) {
13373       {
13374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (std::exception& e) {
13377       {
13378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13379       };
13380     } catch (Dali::DaliException e) {
13381       {
13382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13383       };
13384     } catch (...) {
13385       {
13386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13387       };
13388     }
13389   }
13390
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13399   jresult = (void *)result;
13400   return jresult;
13401 }
13402
13403
13404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13405   void * jresult ;
13406   Dali::Matrix3 *result = 0 ;
13407
13408   {
13409     try {
13410       result = (Dali::Matrix3 *)new Dali::Matrix3();
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13418       };
13419     } catch (Dali::DaliException e) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13422       };
13423     } catch (...) {
13424       {
13425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13426       };
13427     }
13428   }
13429
13430   jresult = (void *)result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13436   void * jresult ;
13437   Dali::Matrix3 *arg1 = 0 ;
13438   Dali::Matrix3 *result = 0 ;
13439
13440   arg1 = (Dali::Matrix3 *)jarg1;
13441   if (!arg1) {
13442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13443     return 0;
13444   }
13445   {
13446     try {
13447       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13455       };
13456     } catch (Dali::DaliException e) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13463       };
13464     }
13465   }
13466
13467   jresult = (void *)result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13473   void * jresult ;
13474   Dali::Matrix *arg1 = 0 ;
13475   Dali::Matrix3 *result = 0 ;
13476
13477   arg1 = (Dali::Matrix *)jarg1;
13478   if (!arg1) {
13479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13480     return 0;
13481   }
13482   {
13483     try {
13484       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13485     } catch (std::out_of_range& e) {
13486       {
13487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13488       };
13489     } catch (std::exception& e) {
13490       {
13491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13492       };
13493     } catch (Dali::DaliException e) {
13494       {
13495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13496       };
13497     } catch (...) {
13498       {
13499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13500       };
13501     }
13502   }
13503
13504   jresult = (void *)result;
13505   return jresult;
13506 }
13507
13508
13509 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) {
13510   void * jresult ;
13511   float arg1 ;
13512   float arg2 ;
13513   float arg3 ;
13514   float arg4 ;
13515   float arg5 ;
13516   float arg6 ;
13517   float arg7 ;
13518   float arg8 ;
13519   float arg9 ;
13520   Dali::Matrix3 *result = 0 ;
13521
13522   arg1 = (float)jarg1;
13523   arg2 = (float)jarg2;
13524   arg3 = (float)jarg3;
13525   arg4 = (float)jarg4;
13526   arg5 = (float)jarg5;
13527   arg6 = (float)jarg6;
13528   arg7 = (float)jarg7;
13529   arg8 = (float)jarg8;
13530   arg9 = (float)jarg9;
13531   {
13532     try {
13533       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13534     } catch (std::out_of_range& e) {
13535       {
13536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13537       };
13538     } catch (std::exception& e) {
13539       {
13540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13541       };
13542     } catch (Dali::DaliException e) {
13543       {
13544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13545       };
13546     } catch (...) {
13547       {
13548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13549       };
13550     }
13551   }
13552
13553   jresult = (void *)result;
13554   return jresult;
13555 }
13556
13557
13558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13559   void * jresult ;
13560   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13561   Dali::Matrix3 *arg2 = 0 ;
13562   Dali::Matrix3 *result = 0 ;
13563
13564   arg1 = (Dali::Matrix3 *)jarg1;
13565   arg2 = (Dali::Matrix3 *)jarg2;
13566   if (!arg2) {
13567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13568     return 0;
13569   }
13570   {
13571     try {
13572       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13573     } catch (std::out_of_range& e) {
13574       {
13575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13576       };
13577     } catch (std::exception& e) {
13578       {
13579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (Dali::DaliException e) {
13582       {
13583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13598   void * jresult ;
13599   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13600   Dali::Matrix *arg2 = 0 ;
13601   Dali::Matrix3 *result = 0 ;
13602
13603   arg1 = (Dali::Matrix3 *)jarg1;
13604   arg2 = (Dali::Matrix *)jarg2;
13605   if (!arg2) {
13606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13607     return 0;
13608   }
13609   {
13610     try {
13611       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13612     } catch (std::out_of_range& e) {
13613       {
13614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13615       };
13616     } catch (std::exception& e) {
13617       {
13618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13619       };
13620     } catch (Dali::DaliException e) {
13621       {
13622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13623       };
13624     } catch (...) {
13625       {
13626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13627       };
13628     }
13629   }
13630
13631   jresult = (void *)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13637   unsigned int jresult ;
13638   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13639   Dali::Matrix3 *arg2 = 0 ;
13640   bool result;
13641
13642   arg1 = (Dali::Matrix3 *)jarg1;
13643   arg2 = (Dali::Matrix3 *)jarg2;
13644   if (!arg2) {
13645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13646     return 0;
13647   }
13648   {
13649     try {
13650       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13651     } catch (std::out_of_range& e) {
13652       {
13653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13654       };
13655     } catch (std::exception& e) {
13656       {
13657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (Dali::DaliException e) {
13660       {
13661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669
13670   jresult = result;
13671   return jresult;
13672 }
13673
13674
13675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13676   unsigned int jresult ;
13677   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13678   Dali::Matrix3 *arg2 = 0 ;
13679   bool result;
13680
13681   arg1 = (Dali::Matrix3 *)jarg1;
13682   arg2 = (Dali::Matrix3 *)jarg2;
13683   if (!arg2) {
13684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13685     return 0;
13686   }
13687   {
13688     try {
13689       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13690     } catch (std::out_of_range& e) {
13691       {
13692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13693       };
13694     } catch (std::exception& e) {
13695       {
13696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13697       };
13698     } catch (Dali::DaliException e) {
13699       {
13700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13701       };
13702     } catch (...) {
13703       {
13704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13705       };
13706     }
13707   }
13708
13709   jresult = result;
13710   return jresult;
13711 }
13712
13713
13714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13715   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13716
13717   arg1 = (Dali::Matrix3 *)jarg1;
13718   {
13719     try {
13720       delete arg1;
13721     } catch (std::out_of_range& e) {
13722       {
13723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13724       };
13725     } catch (std::exception& e) {
13726       {
13727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13728       };
13729     } catch (Dali::DaliException e) {
13730       {
13731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13732       };
13733     } catch (...) {
13734       {
13735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13736       };
13737     }
13738   }
13739
13740 }
13741
13742
13743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745
13746   arg1 = (Dali::Matrix3 *)jarg1;
13747   {
13748     try {
13749       (arg1)->SetIdentity();
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13757       };
13758     } catch (Dali::DaliException e) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13761       };
13762     } catch (...) {
13763       {
13764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13765       };
13766     }
13767   }
13768
13769 }
13770
13771
13772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13773   void * jresult ;
13774   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13775   float *result = 0 ;
13776
13777   arg1 = (Dali::Matrix3 *)jarg1;
13778   {
13779     try {
13780       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13781     } catch (std::out_of_range& e) {
13782       {
13783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13784       };
13785     } catch (std::exception& e) {
13786       {
13787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (Dali::DaliException e) {
13790       {
13791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13806   unsigned int jresult ;
13807   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13808   bool result;
13809
13810   arg1 = (Dali::Matrix3 *)jarg1;
13811   {
13812     try {
13813       result = (bool)(arg1)->Invert();
13814     } catch (std::out_of_range& e) {
13815       {
13816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13817       };
13818     } catch (std::exception& e) {
13819       {
13820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (Dali::DaliException e) {
13823       {
13824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832
13833   jresult = result;
13834   return jresult;
13835 }
13836
13837
13838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13839   unsigned int jresult ;
13840   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Matrix3 *)jarg1;
13844   {
13845     try {
13846       result = (bool)(arg1)->Transpose();
13847     } catch (std::out_of_range& e) {
13848       {
13849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13850       };
13851     } catch (std::exception& e) {
13852       {
13853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (Dali::DaliException e) {
13856       {
13857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865
13866   jresult = result;
13867   return jresult;
13868 }
13869
13870
13871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13872   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13873   float arg2 ;
13874
13875   arg1 = (Dali::Matrix3 *)jarg1;
13876   arg2 = (float)jarg2;
13877   {
13878     try {
13879       (arg1)->Scale(arg2);
13880     } catch (std::out_of_range& e) {
13881       {
13882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13883       };
13884     } catch (std::exception& e) {
13885       {
13886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13887       };
13888     } catch (Dali::DaliException e) {
13889       {
13890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13895       };
13896     }
13897   }
13898
13899 }
13900
13901
13902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13903   float jresult ;
13904   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13905   float result;
13906
13907   arg1 = (Dali::Matrix3 *)jarg1;
13908   {
13909     try {
13910       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13911     } catch (std::out_of_range& e) {
13912       {
13913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13914       };
13915     } catch (std::exception& e) {
13916       {
13917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (Dali::DaliException e) {
13920       {
13921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13922       };
13923     } catch (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929
13930   jresult = result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13936   unsigned int jresult ;
13937   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13938   bool result;
13939
13940   arg1 = (Dali::Matrix3 *)jarg1;
13941   {
13942     try {
13943       result = (bool)(arg1)->ScaledInverseTranspose();
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13951       };
13952     } catch (Dali::DaliException e) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13959       };
13960     }
13961   }
13962
13963   jresult = result;
13964   return jresult;
13965 }
13966
13967
13968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13969   Dali::Matrix3 *arg1 = 0 ;
13970   Dali::Matrix3 *arg2 = 0 ;
13971   Dali::Matrix3 *arg3 = 0 ;
13972
13973   arg1 = (Dali::Matrix3 *)jarg1;
13974   if (!arg1) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13976     return ;
13977   }
13978   arg2 = (Dali::Matrix3 *)jarg2;
13979   if (!arg2) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   arg3 = (Dali::Matrix3 *)jarg3;
13984   if (!arg3) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13986     return ;
13987   }
13988   {
13989     try {
13990       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13998       };
13999     } catch (Dali::DaliException e) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14002       };
14003     } catch (...) {
14004       {
14005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14006       };
14007     }
14008   }
14009
14010 }
14011
14012
14013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14014   float jresult ;
14015   float arg1 ;
14016   float arg2 ;
14017   float result;
14018
14019   arg1 = (float)jarg1;
14020   arg2 = (float)jarg2;
14021   {
14022     try {
14023       result = (float)Dali::Random::Range(arg1,arg2);
14024     } catch (std::out_of_range& e) {
14025       {
14026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (std::exception& e) {
14029       {
14030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14031       };
14032     } catch (Dali::DaliException e) {
14033       {
14034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14039       };
14040     }
14041   }
14042
14043   jresult = result;
14044   return jresult;
14045 }
14046
14047
14048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14049   void * jresult ;
14050   Dali::Vector4 result;
14051
14052   {
14053     try {
14054       result = Dali::Random::Axis();
14055     } catch (std::out_of_range& e) {
14056       {
14057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14058       };
14059     } catch (std::exception& e) {
14060       {
14061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14062       };
14063     } catch (Dali::DaliException e) {
14064       {
14065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14066       };
14067     } catch (...) {
14068       {
14069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14070       };
14071     }
14072   }
14073
14074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14075   return jresult;
14076 }
14077
14078
14079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14080   void * jresult ;
14081   Dali::AngleAxis *result = 0 ;
14082
14083   {
14084     try {
14085       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14086     } catch (std::out_of_range& e) {
14087       {
14088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (std::exception& e) {
14091       {
14092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14093       };
14094     } catch (Dali::DaliException e) {
14095       {
14096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14101       };
14102     }
14103   }
14104
14105   jresult = (void *)result;
14106   return jresult;
14107 }
14108
14109
14110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14111   void * jresult ;
14112   Dali::Radian arg1 ;
14113   Dali::Vector3 *arg2 = 0 ;
14114   Dali::Radian *argp1 ;
14115   Dali::AngleAxis *result = 0 ;
14116
14117   argp1 = (Dali::Radian *)jarg1;
14118   if (!argp1) {
14119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14120     return 0;
14121   }
14122   arg1 = *argp1;
14123   arg2 = (Dali::Vector3 *)jarg2;
14124   if (!arg2) {
14125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14126     return 0;
14127   }
14128   {
14129     try {
14130       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (Dali::DaliException e) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14142       };
14143     } catch (...) {
14144       {
14145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14146       };
14147     }
14148   }
14149
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14158
14159   arg1 = (Dali::AngleAxis *)jarg1;
14160   arg2 = (Dali::Radian *)jarg2;
14161   if (arg1) (arg1)->angle = *arg2;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14166   void * jresult ;
14167   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14168   Dali::Radian *result = 0 ;
14169
14170   arg1 = (Dali::AngleAxis *)jarg1;
14171   result = (Dali::Radian *)& ((arg1)->angle);
14172   jresult = (void *)result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14178   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14179   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14180
14181   arg1 = (Dali::AngleAxis *)jarg1;
14182   arg2 = (Dali::Vector3 *)jarg2;
14183   if (arg1) (arg1)->axis = *arg2;
14184 }
14185
14186
14187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14188   void * jresult ;
14189   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14190   Dali::Vector3 *result = 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   result = (Dali::Vector3 *)& ((arg1)->axis);
14194   jresult = (void *)result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14200   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14201
14202   arg1 = (Dali::AngleAxis *)jarg1;
14203   {
14204     try {
14205       delete arg1;
14206     } catch (std::out_of_range& e) {
14207       {
14208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14209       };
14210     } catch (std::exception& e) {
14211       {
14212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14213       };
14214     } catch (Dali::DaliException e) {
14215       {
14216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14217       };
14218     } catch (...) {
14219       {
14220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14221       };
14222     }
14223   }
14224
14225 }
14226
14227
14228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14229   unsigned int jresult ;
14230   Dali::AngleAxis *arg1 = 0 ;
14231   Dali::AngleAxis *arg2 = 0 ;
14232   bool result;
14233
14234   arg1 = (Dali::AngleAxis *)jarg1;
14235   if (!arg1) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   arg2 = (Dali::AngleAxis *)jarg2;
14240   if (!arg2) {
14241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14242     return 0;
14243   }
14244   {
14245     try {
14246       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (Dali::DaliException e) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14258       };
14259     } catch (...) {
14260       {
14261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14262       };
14263     }
14264   }
14265
14266   jresult = result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14272   unsigned int jresult ;
14273   unsigned int arg1 ;
14274   unsigned int result;
14275
14276   arg1 = (unsigned int)jarg1;
14277   {
14278     try {
14279       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (Dali::DaliException e) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14291       };
14292     } catch (...) {
14293       {
14294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14295       };
14296     }
14297   }
14298
14299   jresult = result;
14300   return jresult;
14301 }
14302
14303
14304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14305   unsigned int jresult ;
14306   unsigned int arg1 ;
14307   bool result;
14308
14309   arg1 = (unsigned int)jarg1;
14310   {
14311     try {
14312       result = (bool)Dali::IsPowerOfTwo(arg1);
14313     } catch (std::out_of_range& e) {
14314       {
14315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14316       };
14317     } catch (std::exception& e) {
14318       {
14319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (Dali::DaliException e) {
14322       {
14323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331
14332   jresult = result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14338   float jresult ;
14339   float arg1 ;
14340   float arg2 ;
14341   float result;
14342
14343   arg1 = (float)jarg1;
14344   arg2 = (float)jarg2;
14345   {
14346     try {
14347       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (Dali::DaliException e) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14359       };
14360     } catch (...) {
14361       {
14362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14363       };
14364     }
14365   }
14366
14367   jresult = result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14373   unsigned int jresult ;
14374   float arg1 ;
14375   bool result;
14376
14377   arg1 = (float)jarg1;
14378   {
14379     try {
14380       result = (bool)Dali::EqualsZero(arg1);
14381     } catch (std::out_of_range& e) {
14382       {
14383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14384       };
14385     } catch (std::exception& e) {
14386       {
14387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (Dali::DaliException e) {
14390       {
14391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399
14400   jresult = result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14406   unsigned int jresult ;
14407   float arg1 ;
14408   float arg2 ;
14409   bool result;
14410
14411   arg1 = (float)jarg1;
14412   arg2 = (float)jarg2;
14413   {
14414     try {
14415       result = (bool)Dali::Equals(arg1,arg2);
14416     } catch (std::out_of_range& e) {
14417       {
14418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14419       };
14420     } catch (std::exception& e) {
14421       {
14422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (Dali::DaliException e) {
14425       {
14426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14427       };
14428     } catch (...) {
14429       {
14430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14431       };
14432     }
14433   }
14434
14435   jresult = result;
14436   return jresult;
14437 }
14438
14439
14440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14441   unsigned int jresult ;
14442   float arg1 ;
14443   float arg2 ;
14444   float arg3 ;
14445   bool result;
14446
14447   arg1 = (float)jarg1;
14448   arg2 = (float)jarg2;
14449   arg3 = (float)jarg3;
14450   {
14451     try {
14452       result = (bool)Dali::Equals(arg1,arg2,arg3);
14453     } catch (std::out_of_range& e) {
14454       {
14455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14456       };
14457     } catch (std::exception& e) {
14458       {
14459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14460       };
14461     } catch (Dali::DaliException e) {
14462       {
14463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14464       };
14465     } catch (...) {
14466       {
14467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14468       };
14469     }
14470   }
14471
14472   jresult = result;
14473   return jresult;
14474 }
14475
14476
14477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14478   float jresult ;
14479   float arg1 ;
14480   int arg2 ;
14481   float result;
14482
14483   arg1 = (float)jarg1;
14484   arg2 = (int)jarg2;
14485   {
14486     try {
14487       result = (float)Dali::Round(arg1,arg2);
14488     } catch (std::out_of_range& e) {
14489       {
14490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14491       };
14492     } catch (std::exception& e) {
14493       {
14494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (Dali::DaliException e) {
14497       {
14498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506
14507   jresult = result;
14508   return jresult;
14509 }
14510
14511
14512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14513   float jresult ;
14514   float arg1 ;
14515   float arg2 ;
14516   float arg3 ;
14517   float result;
14518
14519   arg1 = (float)jarg1;
14520   arg2 = (float)jarg2;
14521   arg3 = (float)jarg3;
14522   {
14523     try {
14524       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14525     } catch (std::out_of_range& e) {
14526       {
14527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14528       };
14529     } catch (std::exception& e) {
14530       {
14531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14532       };
14533     } catch (Dali::DaliException e) {
14534       {
14535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14536       };
14537     } catch (...) {
14538       {
14539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14540       };
14541     }
14542   }
14543
14544   jresult = result;
14545   return jresult;
14546 }
14547
14548
14549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14550   float jresult ;
14551   float arg1 ;
14552   float arg2 ;
14553   float arg3 ;
14554   float arg4 ;
14555   float result;
14556
14557   arg1 = (float)jarg1;
14558   arg2 = (float)jarg2;
14559   arg3 = (float)jarg3;
14560   arg4 = (float)jarg4;
14561   {
14562     try {
14563       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14564     } catch (std::out_of_range& e) {
14565       {
14566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14567       };
14568     } catch (std::exception& e) {
14569       {
14570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14571       };
14572     } catch (Dali::DaliException e) {
14573       {
14574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14575       };
14576     } catch (...) {
14577       {
14578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14579       };
14580     }
14581   }
14582
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_INDEX;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_KEY;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14609   int jresult ;
14610   int result;
14611
14612   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14613   jresult = result;
14614   return jresult;
14615 }
14616
14617
14618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14619   void * jresult ;
14620   Dali::Handle *arg1 = 0 ;
14621   Dali::Property::Index arg2 ;
14622   Dali::Property *result = 0 ;
14623
14624   arg1 = (Dali::Handle *)jarg1;
14625   if (!arg1) {
14626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14627     return 0;
14628   }
14629   arg2 = (Dali::Property::Index)jarg2;
14630   {
14631     try {
14632       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14633     } catch (std::out_of_range& e) {
14634       {
14635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (std::exception& e) {
14638       {
14639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14640       };
14641     } catch (Dali::DaliException e) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14644       };
14645     } catch (...) {
14646       {
14647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14648       };
14649     }
14650   }
14651
14652   jresult = (void *)result;
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14658   void * jresult ;
14659   Dali::Handle *arg1 = 0 ;
14660   Dali::Property::Index arg2 ;
14661   int arg3 ;
14662   Dali::Property *result = 0 ;
14663
14664   arg1 = (Dali::Handle *)jarg1;
14665   if (!arg1) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14667     return 0;
14668   }
14669   arg2 = (Dali::Property::Index)jarg2;
14670   arg3 = (int)jarg3;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14699   void * jresult ;
14700   Dali::Handle *arg1 = 0 ;
14701   std::string *arg2 = 0 ;
14702   Dali::Property *result = 0 ;
14703
14704   arg1 = (Dali::Handle *)jarg1;
14705   if (!arg1) {
14706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14707     return 0;
14708   }
14709   if (!jarg2) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14711     return 0;
14712   }
14713   std::string arg2_str(jarg2);
14714   arg2 = &arg2_str;
14715   {
14716     try {
14717       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14718     } catch (std::out_of_range& e) {
14719       {
14720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14721       };
14722     } catch (std::exception& e) {
14723       {
14724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (Dali::DaliException e) {
14727       {
14728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14729       };
14730     } catch (...) {
14731       {
14732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14733       };
14734     }
14735   }
14736
14737   jresult = (void *)result;
14738
14739   //argout typemap for const std::string&
14740
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14746   void * jresult ;
14747   Dali::Handle *arg1 = 0 ;
14748   std::string *arg2 = 0 ;
14749   int arg3 ;
14750   Dali::Property *result = 0 ;
14751
14752   arg1 = (Dali::Handle *)jarg1;
14753   if (!arg1) {
14754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14755     return 0;
14756   }
14757   if (!jarg2) {
14758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14759     return 0;
14760   }
14761   std::string arg2_str(jarg2);
14762   arg2 = &arg2_str;
14763   arg3 = (int)jarg3;
14764   {
14765     try {
14766       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14767     } catch (std::out_of_range& e) {
14768       {
14769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (std::exception& e) {
14772       {
14773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14774       };
14775     } catch (Dali::DaliException e) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14778       };
14779     } catch (...) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14782       };
14783     }
14784   }
14785
14786   jresult = (void *)result;
14787
14788   //argout typemap for const std::string&
14789
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   {
14799     try {
14800       delete arg1;
14801     } catch (std::out_of_range& e) {
14802       {
14803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14804       };
14805     } catch (std::exception& e) {
14806       {
14807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14808       };
14809     } catch (Dali::DaliException e) {
14810       {
14811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14812       };
14813     } catch (...) {
14814       {
14815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14816       };
14817     }
14818   }
14819
14820 }
14821
14822
14823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14824   Dali::Property *arg1 = (Dali::Property *) 0 ;
14825   Dali::Handle *arg2 = 0 ;
14826
14827   arg1 = (Dali::Property *)jarg1;
14828   arg2 = (Dali::Handle *)jarg2;
14829   if (!arg2) {
14830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14831     return ;
14832   }
14833   if (arg1) (arg1)->object = *arg2;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14838   void * jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   Dali::Handle *result = 0 ;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14844   jresult = (void *)result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14850   Dali::Property *arg1 = (Dali::Property *) 0 ;
14851   Dali::Property::Index arg2 ;
14852
14853   arg1 = (Dali::Property *)jarg1;
14854   arg2 = (Dali::Property::Index)jarg2;
14855   if (arg1) (arg1)->propertyIndex = arg2;
14856 }
14857
14858
14859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14860   int jresult ;
14861   Dali::Property *arg1 = (Dali::Property *) 0 ;
14862   Dali::Property::Index result;
14863
14864   arg1 = (Dali::Property *)jarg1;
14865   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14866   jresult = result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14872   Dali::Property *arg1 = (Dali::Property *) 0 ;
14873   int arg2 ;
14874
14875   arg1 = (Dali::Property *)jarg1;
14876   arg2 = (int)jarg2;
14877   if (arg1) (arg1)->componentIndex = arg2;
14878 }
14879
14880
14881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14882   int jresult ;
14883   Dali::Property *arg1 = (Dali::Property *) 0 ;
14884   int result;
14885
14886   arg1 = (Dali::Property *)jarg1;
14887   result = (int) ((arg1)->componentIndex);
14888   jresult = result;
14889   return jresult;
14890 }
14891
14892
14893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14894   void * jresult ;
14895   Dali::Property::Array *result = 0 ;
14896
14897   {
14898     try {
14899       result = (Dali::Property::Array *)new Dali::Property::Array();
14900     } catch (std::out_of_range& e) {
14901       {
14902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14903       };
14904     } catch (std::exception& e) {
14905       {
14906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (Dali::DaliException e) {
14909       {
14910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14925   void * jresult ;
14926   Dali::Property::Array *arg1 = 0 ;
14927   Dali::Property::Array *result = 0 ;
14928
14929   arg1 = (Dali::Property::Array *)jarg1;
14930   if (!arg1) {
14931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14932     return 0;
14933   }
14934   {
14935     try {
14936       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14937     } catch (std::out_of_range& e) {
14938       {
14939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (std::exception& e) {
14942       {
14943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14944       };
14945     } catch (Dali::DaliException e) {
14946       {
14947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14948       };
14949     } catch (...) {
14950       {
14951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14952       };
14953     }
14954   }
14955
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963
14964   arg1 = (Dali::Property::Array *)jarg1;
14965   {
14966     try {
14967       delete arg1;
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14975       };
14976     } catch (Dali::DaliException e) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14983       };
14984     }
14985   }
14986
14987 }
14988
14989
14990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14991   unsigned long jresult ;
14992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14993   Dali::Property::Array::SizeType result;
14994
14995   arg1 = (Dali::Property::Array *)jarg1;
14996   {
14997     try {
14998       result = ((Dali::Property::Array const *)arg1)->Size();
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (Dali::DaliException e) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15010       };
15011     } catch (...) {
15012       {
15013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15014       };
15015     }
15016   }
15017
15018   jresult = (unsigned long)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15024   unsigned long jresult ;
15025   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15026   Dali::Property::Array::SizeType result;
15027
15028   arg1 = (Dali::Property::Array *)jarg1;
15029   {
15030     try {
15031       result = ((Dali::Property::Array const *)arg1)->Count();
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (Dali::DaliException e) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050
15051   jresult = (unsigned long)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15057   unsigned int jresult ;
15058   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15059   bool result;
15060
15061   arg1 = (Dali::Property::Array *)jarg1;
15062   {
15063     try {
15064       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (Dali::DaliException e) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15076       };
15077     } catch (...) {
15078       {
15079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15080       };
15081     }
15082   }
15083
15084   jresult = result;
15085   return jresult;
15086 }
15087
15088
15089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15090   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   {
15094     try {
15095       (arg1)->Clear();
15096     } catch (std::out_of_range& e) {
15097       {
15098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15099       };
15100     } catch (std::exception& e) {
15101       {
15102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15103       };
15104     } catch (Dali::DaliException e) {
15105       {
15106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15111       };
15112     }
15113   }
15114
15115 }
15116
15117
15118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15119   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15120   Dali::Property::Array::SizeType arg2 ;
15121
15122   arg1 = (Dali::Property::Array *)jarg1;
15123   arg2 = (Dali::Property::Array::SizeType)jarg2;
15124   {
15125     try {
15126       (arg1)->Reserve(arg2);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15134       };
15135     } catch (Dali::DaliException e) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15142       };
15143     }
15144   }
15145
15146 }
15147
15148
15149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15150   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15151   Dali::Property::Array::SizeType arg2 ;
15152
15153   arg1 = (Dali::Property::Array *)jarg1;
15154   arg2 = (Dali::Property::Array::SizeType)jarg2;
15155   {
15156     try {
15157       (arg1)->Resize(arg2);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15165       };
15166     } catch (Dali::DaliException e) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15173       };
15174     }
15175   }
15176
15177 }
15178
15179
15180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15181   unsigned long jresult ;
15182   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15183   Dali::Property::Array::SizeType result;
15184
15185   arg1 = (Dali::Property::Array *)jarg1;
15186   {
15187     try {
15188       result = (arg1)->Capacity();
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (Dali::DaliException e) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15200       };
15201     } catch (...) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15204       };
15205     }
15206   }
15207
15208   jresult = (unsigned long)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15214   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15215   Dali::Property::Value *arg2 = 0 ;
15216
15217   arg1 = (Dali::Property::Array *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return ;
15222   }
15223   {
15224     try {
15225       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15233       };
15234     } catch (Dali::DaliException e) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15241       };
15242     }
15243   }
15244
15245 }
15246
15247
15248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15249   void * jresult ;
15250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15251   Dali::Property::Value *arg2 = 0 ;
15252   Dali::Property::Array *result = 0 ;
15253
15254   arg1 = (Dali::Property::Array *)jarg1;
15255   arg2 = (Dali::Property::Value *)jarg2;
15256   if (!arg2) {
15257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15258     return 0;
15259   }
15260   {
15261     try {
15262       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (Dali::DaliException e) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15274       };
15275     } catch (...) {
15276       {
15277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15278       };
15279     }
15280   }
15281
15282   jresult = (void *)result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15288   void * jresult ;
15289   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15290   Dali::Property::Array::SizeType arg2 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Array *)jarg1;
15294   arg2 = (Dali::Property::Array::SizeType)jarg2;
15295   {
15296     try {
15297       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15298     } catch (std::out_of_range& e) {
15299       {
15300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15301       };
15302     } catch (std::exception& e) {
15303       {
15304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15305       };
15306     } catch (Dali::DaliException e) {
15307       {
15308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15309       };
15310     } catch (...) {
15311       {
15312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15313       };
15314     }
15315   }
15316
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15323   void * jresult ;
15324   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15325   Dali::Property::Array::SizeType arg2 ;
15326   Dali::Property::Value *result = 0 ;
15327
15328   arg1 = (Dali::Property::Array *)jarg1;
15329   arg2 = (Dali::Property::Array::SizeType)jarg2;
15330   {
15331     try {
15332       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15333     } catch (std::out_of_range& e) {
15334       {
15335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15336       };
15337     } catch (std::exception& e) {
15338       {
15339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (Dali::DaliException e) {
15342       {
15343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351
15352   jresult = (void *)result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15358   void * jresult ;
15359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15360   Dali::Property::Array *arg2 = 0 ;
15361   Dali::Property::Array *result = 0 ;
15362
15363   arg1 = (Dali::Property::Array *)jarg1;
15364   arg2 = (Dali::Property::Array *)jarg2;
15365   if (!arg2) {
15366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15367     return 0;
15368   }
15369   {
15370     try {
15371       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15372     } catch (std::out_of_range& e) {
15373       {
15374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (std::exception& e) {
15377       {
15378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15379       };
15380     } catch (Dali::DaliException e) {
15381       {
15382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15383       };
15384     } catch (...) {
15385       {
15386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15387       };
15388     }
15389   }
15390
15391   jresult = (void *)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   enum Dali::Property::Key::Type arg2 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   arg2 = (enum Dali::Property::Key::Type)jarg2;
15402   if (arg1) (arg1)->type = arg2;
15403 }
15404
15405
15406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15407   int jresult ;
15408   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15409   enum Dali::Property::Key::Type result;
15410
15411   arg1 = (Dali::Property::Key *)jarg1;
15412   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15413   jresult = (int)result;
15414   return jresult;
15415 }
15416
15417
15418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15419   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15420   Dali::Property::Index arg2 ;
15421
15422   arg1 = (Dali::Property::Key *)jarg1;
15423   arg2 = (Dali::Property::Index)jarg2;
15424   if (arg1) (arg1)->indexKey = arg2;
15425 }
15426
15427
15428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15429   int jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   Dali::Property::Index result;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (Dali::Property::Index) ((arg1)->indexKey);
15435   jresult = result;
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15441   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15442   std::string *arg2 = 0 ;
15443
15444   arg1 = (Dali::Property::Key *)jarg1;
15445   if (!jarg2) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return ;
15448   }
15449   std::string arg2_str(jarg2);
15450   arg2 = &arg2_str;
15451   if (arg1) (arg1)->stringKey = *arg2;
15452
15453   //argout typemap for const std::string&
15454
15455 }
15456
15457
15458 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15459   char * jresult ;
15460   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15461   std::string *result = 0 ;
15462
15463   arg1 = (Dali::Property::Key *)jarg1;
15464   result = (std::string *) & ((arg1)->stringKey);
15465   jresult = SWIG_csharp_string_callback(result->c_str());
15466   return jresult;
15467 }
15468
15469
15470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15471   void * jresult ;
15472   std::string *arg1 = 0 ;
15473   Dali::Property::Key *result = 0 ;
15474
15475   if (!jarg1) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15477     return 0;
15478   }
15479   std::string arg1_str(jarg1);
15480   arg1 = &arg1_str;
15481   {
15482     try {
15483       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15484     } catch (std::out_of_range& e) {
15485       {
15486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15487       };
15488     } catch (std::exception& e) {
15489       {
15490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15491       };
15492     } catch (Dali::DaliException e) {
15493       {
15494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15495       };
15496     } catch (...) {
15497       {
15498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15499       };
15500     }
15501   }
15502
15503   jresult = (void *)result;
15504
15505   //argout typemap for const std::string&
15506
15507   return jresult;
15508 }
15509
15510
15511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15512   void * jresult ;
15513   Dali::Property::Index arg1 ;
15514   Dali::Property::Key *result = 0 ;
15515
15516   arg1 = (Dali::Property::Index)jarg1;
15517   {
15518     try {
15519       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15520     } catch (std::out_of_range& e) {
15521       {
15522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (std::exception& e) {
15525       {
15526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15527       };
15528     } catch (Dali::DaliException e) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15531       };
15532     } catch (...) {
15533       {
15534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15535       };
15536     }
15537   }
15538
15539   jresult = (void *)result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15545   unsigned int jresult ;
15546   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15547   std::string *arg2 = 0 ;
15548   bool result;
15549
15550   arg1 = (Dali::Property::Key *)jarg1;
15551   if (!jarg2) {
15552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15553     return 0;
15554   }
15555   std::string arg2_str(jarg2);
15556   arg2 = &arg2_str;
15557   {
15558     try {
15559       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15560     } catch (std::out_of_range& e) {
15561       {
15562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15563       };
15564     } catch (std::exception& e) {
15565       {
15566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15567       };
15568     } catch (Dali::DaliException e) {
15569       {
15570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15571       };
15572     } catch (...) {
15573       {
15574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15575       };
15576     }
15577   }
15578
15579   jresult = result;
15580
15581   //argout typemap for const std::string&
15582
15583   return jresult;
15584 }
15585
15586
15587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15588   unsigned int jresult ;
15589   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15590   Dali::Property::Index arg2 ;
15591   bool result;
15592
15593   arg1 = (Dali::Property::Key *)jarg1;
15594   arg2 = (Dali::Property::Index)jarg2;
15595   {
15596     try {
15597       result = (bool)(arg1)->operator ==(arg2);
15598     } catch (std::out_of_range& e) {
15599       {
15600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15601       };
15602     } catch (std::exception& e) {
15603       {
15604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15605       };
15606     } catch (Dali::DaliException e) {
15607       {
15608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15609       };
15610     } catch (...) {
15611       {
15612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15613       };
15614     }
15615   }
15616
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15625   Dali::Property::Key *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Key *)jarg1;
15629   arg2 = (Dali::Property::Key *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (Dali::DaliException e) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15648       };
15649     } catch (...) {
15650       {
15651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15652       };
15653     }
15654   }
15655
15656   jresult = result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15662   unsigned int jresult ;
15663   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15664   std::string *arg2 = 0 ;
15665   bool result;
15666
15667   arg1 = (Dali::Property::Key *)jarg1;
15668   if (!jarg2) {
15669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15670     return 0;
15671   }
15672   std::string arg2_str(jarg2);
15673   arg2 = &arg2_str;
15674   {
15675     try {
15676       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (Dali::DaliException e) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15688       };
15689     } catch (...) {
15690       {
15691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15692       };
15693     }
15694   }
15695
15696   jresult = result;
15697
15698   //argout typemap for const std::string&
15699
15700   return jresult;
15701 }
15702
15703
15704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15705   unsigned int jresult ;
15706   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15707   Dali::Property::Index arg2 ;
15708   bool result;
15709
15710   arg1 = (Dali::Property::Key *)jarg1;
15711   arg2 = (Dali::Property::Index)jarg2;
15712   {
15713     try {
15714       result = (bool)(arg1)->operator !=(arg2);
15715     } catch (std::out_of_range& e) {
15716       {
15717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (std::exception& e) {
15720       {
15721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15722       };
15723     } catch (Dali::DaliException e) {
15724       {
15725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15726       };
15727     } catch (...) {
15728       {
15729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15730       };
15731     }
15732   }
15733
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15742   Dali::Property::Key *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Key *)jarg1;
15746   arg2 = (Dali::Property::Key *)jarg2;
15747   if (!arg2) {
15748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15749     return 0;
15750   }
15751   {
15752     try {
15753       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (Dali::DaliException e) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15765       };
15766     } catch (...) {
15767       {
15768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15769       };
15770     }
15771   }
15772
15773   jresult = result;
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15779   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15780
15781   arg1 = (Dali::Property::Key *)jarg1;
15782   {
15783     try {
15784       delete arg1;
15785     } catch (std::out_of_range& e) {
15786       {
15787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15788       };
15789     } catch (std::exception& e) {
15790       {
15791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15792       };
15793     } catch (Dali::DaliException e) {
15794       {
15795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15796       };
15797     } catch (...) {
15798       {
15799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15800       };
15801     }
15802   }
15803
15804 }
15805
15806
15807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15808   void * jresult ;
15809   Dali::Property::Map *result = 0 ;
15810
15811   {
15812     try {
15813       result = (Dali::Property::Map *)new Dali::Property::Map();
15814     } catch (std::out_of_range& e) {
15815       {
15816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15817       };
15818     } catch (std::exception& e) {
15819       {
15820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15821       };
15822     } catch (Dali::DaliException e) {
15823       {
15824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15825       };
15826     } catch (...) {
15827       {
15828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15829       };
15830     }
15831   }
15832
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15839   void * jresult ;
15840   Dali::Property::Map *arg1 = 0 ;
15841   Dali::Property::Map *result = 0 ;
15842
15843   arg1 = (Dali::Property::Map *)jarg1;
15844   if (!arg1) {
15845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15846     return 0;
15847   }
15848   {
15849     try {
15850       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15851     } catch (std::out_of_range& e) {
15852       {
15853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (std::exception& e) {
15856       {
15857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (Dali::DaliException e) {
15860       {
15861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869
15870   jresult = (void *)result;
15871   return jresult;
15872 }
15873
15874
15875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877
15878   arg1 = (Dali::Property::Map *)jarg1;
15879   {
15880     try {
15881       delete arg1;
15882     } catch (std::out_of_range& e) {
15883       {
15884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15885       };
15886     } catch (std::exception& e) {
15887       {
15888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15889       };
15890     } catch (Dali::DaliException e) {
15891       {
15892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15893       };
15894     } catch (...) {
15895       {
15896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15897       };
15898     }
15899   }
15900
15901 }
15902
15903
15904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15905   unsigned long jresult ;
15906   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15907   Dali::Property::Map::SizeType result;
15908
15909   arg1 = (Dali::Property::Map *)jarg1;
15910   {
15911     try {
15912       result = ((Dali::Property::Map const *)arg1)->Count();
15913     } catch (std::out_of_range& e) {
15914       {
15915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15916       };
15917     } catch (std::exception& e) {
15918       {
15919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15920       };
15921     } catch (Dali::DaliException e) {
15922       {
15923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15924       };
15925     } catch (...) {
15926       {
15927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15928       };
15929     }
15930   }
15931
15932   jresult = (unsigned long)result;
15933   return jresult;
15934 }
15935
15936
15937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15938   unsigned int jresult ;
15939   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15940   bool result;
15941
15942   arg1 = (Dali::Property::Map *)jarg1;
15943   {
15944     try {
15945       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15946     } catch (std::out_of_range& e) {
15947       {
15948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15949       };
15950     } catch (std::exception& e) {
15951       {
15952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15953       };
15954     } catch (Dali::DaliException e) {
15955       {
15956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15957       };
15958     } catch (...) {
15959       {
15960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15961       };
15962     }
15963   }
15964
15965   jresult = result;
15966   return jresult;
15967 }
15968
15969
15970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15971   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15972   char *arg2 = (char *) 0 ;
15973   Dali::Property::Value *arg3 = 0 ;
15974
15975   arg1 = (Dali::Property::Map *)jarg1;
15976   arg2 = (char *)jarg2;
15977   arg3 = (Dali::Property::Value *)jarg3;
15978   if (!arg3) {
15979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15980     return ;
15981   }
15982   {
15983     try {
15984       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15985     } catch (std::out_of_range& e) {
15986       {
15987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15988       };
15989     } catch (std::exception& e) {
15990       {
15991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15992       };
15993     } catch (Dali::DaliException e) {
15994       {
15995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15996       };
15997     } catch (...) {
15998       {
15999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16000       };
16001     }
16002   }
16003
16004 }
16005
16006
16007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16008   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16009   Dali::Property::Index arg2 ;
16010   Dali::Property::Value *arg3 = 0 ;
16011
16012   arg1 = (Dali::Property::Map *)jarg1;
16013   arg2 = (Dali::Property::Index)jarg2;
16014   arg3 = (Dali::Property::Value *)jarg3;
16015   if (!arg3) {
16016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16017     return ;
16018   }
16019   {
16020     try {
16021       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16022     } catch (std::out_of_range& e) {
16023       {
16024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16025       };
16026     } catch (std::exception& e) {
16027       {
16028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16029       };
16030     } catch (Dali::DaliException e) {
16031       {
16032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16033       };
16034     } catch (...) {
16035       {
16036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16037       };
16038     }
16039   }
16040
16041 }
16042
16043
16044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16045   void * jresult ;
16046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16047   char *arg2 = (char *) 0 ;
16048   Dali::Property::Value *arg3 = 0 ;
16049   Dali::Property::Map *result = 0 ;
16050
16051   arg1 = (Dali::Property::Map *)jarg1;
16052   arg2 = (char *)jarg2;
16053   arg3 = (Dali::Property::Value *)jarg3;
16054   if (!arg3) {
16055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16056     return 0;
16057   }
16058   {
16059     try {
16060       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16061     } catch (std::out_of_range& e) {
16062       {
16063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (std::exception& e) {
16066       {
16067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (Dali::DaliException e) {
16070       {
16071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079
16080   jresult = (void *)result;
16081   return jresult;
16082 }
16083
16084
16085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16086   void * jresult ;
16087   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16088   Dali::Property::Index arg2 ;
16089   Dali::Property::Value *arg3 = 0 ;
16090   Dali::Property::Map *result = 0 ;
16091
16092   arg1 = (Dali::Property::Map *)jarg1;
16093   arg2 = (Dali::Property::Index)jarg2;
16094   arg3 = (Dali::Property::Value *)jarg3;
16095   if (!arg3) {
16096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16097     return 0;
16098   }
16099   {
16100     try {
16101       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16102     } catch (std::out_of_range& e) {
16103       {
16104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16105       };
16106     } catch (std::exception& e) {
16107       {
16108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (Dali::DaliException e) {
16111       {
16112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16127   void * jresult ;
16128   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16129   Dali::Property::Map::SizeType arg2 ;
16130   Dali::Property::Value *result = 0 ;
16131
16132   arg1 = (Dali::Property::Map *)jarg1;
16133   arg2 = (Dali::Property::Map::SizeType)jarg2;
16134   {
16135     try {
16136       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (Dali::DaliException e) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16162   char * jresult ;
16163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16164   Dali::Property::Map::SizeType arg2 ;
16165   std::string *result = 0 ;
16166
16167   arg1 = (Dali::Property::Map *)jarg1;
16168   arg2 = (Dali::Property::Map::SizeType)jarg2;
16169   {
16170     try {
16171       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (Dali::DaliException e) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190
16191   jresult = SWIG_csharp_string_callback(result->c_str());
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16197   void * jresult ;
16198   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16199   Dali::Property::Map::SizeType arg2 ;
16200   SwigValueWrapper< Dali::Property::Key > result;
16201
16202   arg1 = (Dali::Property::Map *)jarg1;
16203   arg2 = (Dali::Property::Map::SizeType)jarg2;
16204   {
16205     try {
16206       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16207     } catch (std::out_of_range& e) {
16208       {
16209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16210       };
16211     } catch (std::exception& e) {
16212       {
16213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16214       };
16215     } catch (Dali::DaliException e) {
16216       {
16217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16218       };
16219     } catch (...) {
16220       {
16221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16222       };
16223     }
16224   }
16225
16226   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16227   return jresult;
16228 }
16229
16230
16231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16232   void * jresult ;
16233   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16234   Dali::Property::Map::SizeType arg2 ;
16235   StringValuePair *result = 0 ;
16236
16237   arg1 = (Dali::Property::Map *)jarg1;
16238   arg2 = (Dali::Property::Map::SizeType)jarg2;
16239   {
16240     try {
16241       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16242     } catch (std::out_of_range& e) {
16243       {
16244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16245       };
16246     } catch (std::exception& e) {
16247       {
16248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16249       };
16250     } catch (Dali::DaliException e) {
16251       {
16252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16253       };
16254     } catch (...) {
16255       {
16256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16257       };
16258     }
16259   }
16260
16261   jresult = (void *)result;
16262   return jresult;
16263 }
16264
16265
16266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16267   void * jresult ;
16268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16269   char *arg2 = (char *) 0 ;
16270   Dali::Property::Value *result = 0 ;
16271
16272   arg1 = (Dali::Property::Map *)jarg1;
16273   arg2 = (char *)jarg2;
16274   {
16275     try {
16276       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16277     } catch (std::out_of_range& e) {
16278       {
16279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (std::exception& e) {
16282       {
16283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16284       };
16285     } catch (Dali::DaliException e) {
16286       {
16287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16288       };
16289     } catch (...) {
16290       {
16291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16292       };
16293     }
16294   }
16295
16296   jresult = (void *)result;
16297   return jresult;
16298 }
16299
16300
16301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16302   void * jresult ;
16303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16304   Dali::Property::Index arg2 ;
16305   Dali::Property::Value *result = 0 ;
16306
16307   arg1 = (Dali::Property::Map *)jarg1;
16308   arg2 = (Dali::Property::Index)jarg2;
16309   {
16310     try {
16311       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16312     } catch (std::out_of_range& e) {
16313       {
16314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (std::exception& e) {
16317       {
16318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16319       };
16320     } catch (Dali::DaliException e) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16323       };
16324     } catch (...) {
16325       {
16326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16327       };
16328     }
16329   }
16330
16331   jresult = (void *)result;
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16337   void * jresult ;
16338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16339   Dali::Property::Index arg2 ;
16340   std::string *arg3 = 0 ;
16341   Dali::Property::Value *result = 0 ;
16342
16343   arg1 = (Dali::Property::Map *)jarg1;
16344   arg2 = (Dali::Property::Index)jarg2;
16345   if (!jarg3) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg3_str(jarg3);
16350   arg3 = &arg3_str;
16351   {
16352     try {
16353       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16354     } catch (std::out_of_range& e) {
16355       {
16356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16357       };
16358     } catch (std::exception& e) {
16359       {
16360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (Dali::DaliException e) {
16363       {
16364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372
16373   jresult = (void *)result;
16374
16375   //argout typemap for const std::string&
16376
16377   return jresult;
16378 }
16379
16380
16381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16382   void * jresult ;
16383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16384   std::string *arg2 = 0 ;
16385   Dali::Property::Type arg3 ;
16386   Dali::Property::Value *result = 0 ;
16387
16388   arg1 = (Dali::Property::Map *)jarg1;
16389   if (!jarg2) {
16390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16391     return 0;
16392   }
16393   std::string arg2_str(jarg2);
16394   arg2 = &arg2_str;
16395   arg3 = (Dali::Property::Type)jarg3;
16396   {
16397     try {
16398       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16399     } catch (std::out_of_range& e) {
16400       {
16401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (std::exception& e) {
16404       {
16405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (Dali::DaliException e) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16410       };
16411     } catch (...) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16414       };
16415     }
16416   }
16417
16418   jresult = (void *)result;
16419
16420   //argout typemap for const std::string&
16421
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16427   void * jresult ;
16428   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16429   Dali::Property::Index arg2 ;
16430   Dali::Property::Type arg3 ;
16431   Dali::Property::Value *result = 0 ;
16432
16433   arg1 = (Dali::Property::Map *)jarg1;
16434   arg2 = (Dali::Property::Index)jarg2;
16435   arg3 = (Dali::Property::Type)jarg3;
16436   {
16437     try {
16438       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16439     } catch (std::out_of_range& e) {
16440       {
16441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16442       };
16443     } catch (std::exception& e) {
16444       {
16445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16446       };
16447     } catch (Dali::DaliException e) {
16448       {
16449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16450       };
16451     } catch (...) {
16452       {
16453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16454       };
16455     }
16456   }
16457
16458   jresult = (void *)result;
16459   return jresult;
16460 }
16461
16462
16463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16464   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   {
16468     try {
16469       (arg1)->Clear();
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16477       };
16478     } catch (Dali::DaliException e) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16481       };
16482     } catch (...) {
16483       {
16484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16485       };
16486     }
16487   }
16488
16489 }
16490
16491
16492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16493   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16494   Dali::Property::Map *arg2 = 0 ;
16495
16496   arg1 = (Dali::Property::Map *)jarg1;
16497   arg2 = (Dali::Property::Map *)jarg2;
16498   if (!arg2) {
16499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16500     return ;
16501   }
16502   {
16503     try {
16504       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16505     } catch (std::out_of_range& e) {
16506       {
16507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16508       };
16509     } catch (std::exception& e) {
16510       {
16511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16512       };
16513     } catch (Dali::DaliException e) {
16514       {
16515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16520       };
16521     }
16522   }
16523
16524 }
16525
16526
16527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16528   void * jresult ;
16529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16530   std::string *arg2 = 0 ;
16531   Dali::Property::Value *result = 0 ;
16532
16533   arg1 = (Dali::Property::Map *)jarg1;
16534   if (!jarg2) {
16535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16536     return 0;
16537   }
16538   std::string arg2_str(jarg2);
16539   arg2 = &arg2_str;
16540   {
16541     try {
16542       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16543     } catch (std::out_of_range& e) {
16544       {
16545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16546       };
16547     } catch (std::exception& e) {
16548       {
16549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (Dali::DaliException e) {
16552       {
16553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16554       };
16555     } catch (...) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16558       };
16559     }
16560   }
16561
16562   jresult = (void *)result;
16563
16564   //argout typemap for const std::string&
16565
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16571   void * jresult ;
16572   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16573   Dali::Property::Index arg2 ;
16574   Dali::Property::Value *result = 0 ;
16575
16576   arg1 = (Dali::Property::Map *)jarg1;
16577   arg2 = (Dali::Property::Index)jarg2;
16578   {
16579     try {
16580       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16581     } catch (std::out_of_range& e) {
16582       {
16583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16584       };
16585     } catch (std::exception& e) {
16586       {
16587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16588       };
16589     } catch (Dali::DaliException e) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16596       };
16597     }
16598   }
16599
16600   jresult = (void *)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16606   void * jresult ;
16607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16608   Dali::Property::Map *arg2 = 0 ;
16609   Dali::Property::Map *result = 0 ;
16610
16611   arg1 = (Dali::Property::Map *)jarg1;
16612   arg2 = (Dali::Property::Map *)jarg2;
16613   if (!arg2) {
16614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16615     return 0;
16616   }
16617   {
16618     try {
16619       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16620     } catch (std::out_of_range& e) {
16621       {
16622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16623       };
16624     } catch (std::exception& e) {
16625       {
16626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16627       };
16628     } catch (Dali::DaliException e) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16631       };
16632     } catch (...) {
16633       {
16634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16635       };
16636     }
16637   }
16638
16639   jresult = (void *)result;
16640   return jresult;
16641 }
16642
16643
16644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16645   void * jresult ;
16646   Dali::Property::Value *result = 0 ;
16647
16648   {
16649     try {
16650       result = (Dali::Property::Value *)new Dali::Property::Value();
16651     } catch (std::out_of_range& e) {
16652       {
16653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16654       };
16655     } catch (std::exception& e) {
16656       {
16657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16658       };
16659     } catch (Dali::DaliException e) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16662       };
16663     } catch (...) {
16664       {
16665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16666       };
16667     }
16668   }
16669
16670   jresult = (void *)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16676   void * jresult ;
16677   bool arg1 ;
16678   Dali::Property::Value *result = 0 ;
16679
16680   arg1 = jarg1 ? true : false;
16681   {
16682     try {
16683       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (Dali::DaliException e) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16699       };
16700     }
16701   }
16702
16703   jresult = (void *)result;
16704   return jresult;
16705 }
16706
16707
16708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16709   void * jresult ;
16710   int arg1 ;
16711   Dali::Property::Value *result = 0 ;
16712
16713   arg1 = (int)jarg1;
16714   {
16715     try {
16716       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16717     } catch (std::out_of_range& e) {
16718       {
16719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16720       };
16721     } catch (std::exception& e) {
16722       {
16723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (Dali::DaliException e) {
16726       {
16727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16728       };
16729     } catch (...) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16732       };
16733     }
16734   }
16735
16736   jresult = (void *)result;
16737   return jresult;
16738 }
16739
16740
16741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16742   void * jresult ;
16743   float arg1 ;
16744   Dali::Property::Value *result = 0 ;
16745
16746   arg1 = (float)jarg1;
16747   {
16748     try {
16749       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16750     } catch (std::out_of_range& e) {
16751       {
16752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16753       };
16754     } catch (std::exception& e) {
16755       {
16756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (Dali::DaliException e) {
16759       {
16760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16761       };
16762     } catch (...) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16765       };
16766     }
16767   }
16768
16769   jresult = (void *)result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16775   void * jresult ;
16776   Dali::Vector2 *arg1 = 0 ;
16777   Dali::Property::Value *result = 0 ;
16778
16779   arg1 = (Dali::Vector2 *)jarg1;
16780   if (!arg1) {
16781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16782     return 0;
16783   }
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector3 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector3 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector4 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector4 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16886   void * jresult ;
16887   Dali::Matrix3 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Matrix3 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16960   void * jresult ;
16961   Dali::Rect< int > *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Rect< int > *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16997   void * jresult ;
16998   Dali::AngleAxis *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::AngleAxis *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17034   void * jresult ;
17035   Dali::Quaternion *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::Quaternion *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17071   void * jresult ;
17072   std::string *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   if (!jarg1) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17077     return 0;
17078   }
17079   std::string arg1_str(jarg1);
17080   arg1 = &arg1_str;
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104
17105   //argout typemap for const std::string&
17106
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17112   void * jresult ;
17113   Dali::Property::Array *arg1 = 0 ;
17114   Dali::Property::Value *result = 0 ;
17115
17116   arg1 = (Dali::Property::Array *)jarg1;
17117   if (!arg1) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17119     return 0;
17120   }
17121   {
17122     try {
17123       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17124     } catch (std::out_of_range& e) {
17125       {
17126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17127       };
17128     } catch (std::exception& e) {
17129       {
17130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (Dali::DaliException e) {
17133       {
17134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Map *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Map *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17186   void * jresult ;
17187   Extents *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Extents *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17209       };
17210     }
17211   }
17212   jresult = (void *)result;
17213   return jresult;
17214 }
17215
17216
17217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17218   void * jresult ;
17219   Dali::Property::Type arg1 ;
17220   Dali::Property::Value *result = 0 ;
17221
17222   arg1 = (Dali::Property::Type)jarg1;
17223   {
17224     try {
17225       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (Dali::DaliException e) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17237       };
17238     } catch (...) {
17239       {
17240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17241       };
17242     }
17243   }
17244
17245   jresult = (void *)result;
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17251   void * jresult ;
17252   Dali::Property::Value *arg1 = 0 ;
17253   Dali::Property::Value *result = 0 ;
17254
17255   arg1 = (Dali::Property::Value *)jarg1;
17256   if (!arg1) {
17257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17258     return 0;
17259   }
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17290   Dali::Property::Value *arg2 = 0 ;
17291   Dali::Property::Value *result = 0 ;
17292
17293   arg1 = (Dali::Property::Value *)jarg1;
17294   arg2 = (Dali::Property::Value *)jarg2;
17295   if (!arg2) {
17296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17297     return 0;
17298   }
17299   {
17300     try {
17301       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17302     } catch (std::out_of_range& e) {
17303       {
17304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (std::exception& e) {
17307       {
17308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17309       };
17310     } catch (Dali::DaliException e) {
17311       {
17312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17313       };
17314     } catch (...) {
17315       {
17316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17317       };
17318     }
17319   }
17320
17321   jresult = (void *)result;
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17327   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17328
17329   arg1 = (Dali::Property::Value *)jarg1;
17330   {
17331     try {
17332       delete arg1;
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17340       };
17341     } catch (Dali::DaliException e) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17348       };
17349     }
17350   }
17351
17352 }
17353
17354
17355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17356   int jresult ;
17357   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17358   Dali::Property::Type result;
17359
17360   arg1 = (Dali::Property::Value *)jarg1;
17361   {
17362     try {
17363       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (Dali::DaliException e) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17375       };
17376     } catch (...) {
17377       {
17378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17379       };
17380     }
17381   }
17382
17383   jresult = (int)result;
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17389   unsigned int jresult ;
17390   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17391   bool *arg2 = 0 ;
17392   bool result;
17393
17394   arg1 = (Dali::Property::Value *)jarg1;
17395   arg2 = (bool *)jarg2;
17396   {
17397     try {
17398       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17399     } catch (std::out_of_range& e) {
17400       {
17401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (std::exception& e) {
17404       {
17405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17406       };
17407     } catch (Dali::DaliException e) {
17408       {
17409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17410       };
17411     } catch (...) {
17412       {
17413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17414       };
17415     }
17416   }
17417
17418   jresult = result;
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17424   unsigned int jresult ;
17425   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17426   float *arg2 = 0 ;
17427   bool result;
17428
17429   arg1 = (Dali::Property::Value *)jarg1;
17430   arg2 = (float *)jarg2;
17431   {
17432     try {
17433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17434     } catch (std::out_of_range& e) {
17435       {
17436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17437       };
17438     } catch (std::exception& e) {
17439       {
17440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17441       };
17442     } catch (Dali::DaliException e) {
17443       {
17444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17445       };
17446     } catch (...) {
17447       {
17448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17449       };
17450     }
17451   }
17452
17453   jresult = result;
17454   return jresult;
17455 }
17456
17457
17458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17459   unsigned int jresult ;
17460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17461   int *arg2 = 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::Property::Value *)jarg1;
17465   arg2 = (int *)jarg2;
17466   {
17467     try {
17468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (Dali::DaliException e) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487
17488   jresult = result;
17489   return jresult;
17490 }
17491
17492
17493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17494   unsigned int jresult ;
17495   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17496   Dali::Rect< int > *arg2 = 0 ;
17497   bool result;
17498
17499   arg1 = (Dali::Property::Value *)jarg1;
17500   arg2 = (Dali::Rect< int > *)jarg2;
17501   if (!arg2) {
17502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17503     return 0;
17504   }
17505   {
17506     try {
17507       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17508     } catch (std::out_of_range& e) {
17509       {
17510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (std::exception& e) {
17513       {
17514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17515       };
17516     } catch (Dali::DaliException e) {
17517       {
17518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17519       };
17520     } catch (...) {
17521       {
17522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17523       };
17524     }
17525   }
17526
17527   jresult = result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17533   unsigned int jresult ;
17534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17535   Dali::Vector2 *arg2 = 0 ;
17536   bool result;
17537
17538   arg1 = (Dali::Property::Value *)jarg1;
17539   arg2 = (Dali::Vector2 *)jarg2;
17540   if (!arg2) {
17541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17542     return 0;
17543   }
17544   {
17545     try {
17546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17547     } catch (std::out_of_range& e) {
17548       {
17549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (std::exception& e) {
17552       {
17553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17554       };
17555     } catch (Dali::DaliException e) {
17556       {
17557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17558       };
17559     } catch (...) {
17560       {
17561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17562       };
17563     }
17564   }
17565
17566   jresult = result;
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17572   unsigned int jresult ;
17573   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17574   Dali::Vector3 *arg2 = 0 ;
17575   bool result;
17576
17577   arg1 = (Dali::Property::Value *)jarg1;
17578   arg2 = (Dali::Vector3 *)jarg2;
17579   if (!arg2) {
17580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17581     return 0;
17582   }
17583   {
17584     try {
17585       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17586     } catch (std::out_of_range& e) {
17587       {
17588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17589       };
17590     } catch (std::exception& e) {
17591       {
17592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17593       };
17594     } catch (Dali::DaliException e) {
17595       {
17596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17597       };
17598     } catch (...) {
17599       {
17600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17601       };
17602     }
17603   }
17604
17605   jresult = result;
17606   return jresult;
17607 }
17608
17609
17610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17611   unsigned int jresult ;
17612   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17613   Dali::Vector4 *arg2 = 0 ;
17614   bool result;
17615
17616   arg1 = (Dali::Property::Value *)jarg1;
17617   arg2 = (Dali::Vector4 *)jarg2;
17618   if (!arg2) {
17619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17620     return 0;
17621   }
17622   {
17623     try {
17624       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (Dali::DaliException e) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17636       };
17637     } catch (...) {
17638       {
17639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17640       };
17641     }
17642   }
17643
17644   jresult = result;
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17650   unsigned int jresult ;
17651   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17652   Dali::Matrix3 *arg2 = 0 ;
17653   bool result;
17654
17655   arg1 = (Dali::Property::Value *)jarg1;
17656   arg2 = (Dali::Matrix3 *)jarg2;
17657   if (!arg2) {
17658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17659     return 0;
17660   }
17661   {
17662     try {
17663       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17664     } catch (std::out_of_range& e) {
17665       {
17666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17667       };
17668     } catch (std::exception& e) {
17669       {
17670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17671       };
17672     } catch (Dali::DaliException e) {
17673       {
17674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17675       };
17676     } catch (...) {
17677       {
17678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17679       };
17680     }
17681   }
17682
17683   jresult = result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17689   unsigned int jresult ;
17690   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17691   Dali::Matrix *arg2 = 0 ;
17692   bool result;
17693
17694   arg1 = (Dali::Property::Value *)jarg1;
17695   arg2 = (Dali::Matrix *)jarg2;
17696   if (!arg2) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17698     return 0;
17699   }
17700   {
17701     try {
17702       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17703     } catch (std::out_of_range& e) {
17704       {
17705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17706       };
17707     } catch (std::exception& e) {
17708       {
17709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17710       };
17711     } catch (Dali::DaliException e) {
17712       {
17713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17718       };
17719     }
17720   }
17721
17722   jresult = result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17728   unsigned int jresult ;
17729   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17730   Dali::AngleAxis *arg2 = 0 ;
17731   bool result;
17732
17733   arg1 = (Dali::Property::Value *)jarg1;
17734   arg2 = (Dali::AngleAxis *)jarg2;
17735   if (!arg2) {
17736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17737     return 0;
17738   }
17739   {
17740     try {
17741       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (Dali::DaliException e) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17753       };
17754     } catch (...) {
17755       {
17756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17757       };
17758     }
17759   }
17760
17761   jresult = result;
17762   return jresult;
17763 }
17764
17765
17766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17767   unsigned int jresult ;
17768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17769   Dali::Quaternion *arg2 = 0 ;
17770   bool result;
17771
17772   arg1 = (Dali::Property::Value *)jarg1;
17773   arg2 = (Dali::Quaternion *)jarg2;
17774   if (!arg2) {
17775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17776     return 0;
17777   }
17778   {
17779     try {
17780       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17781     } catch (std::out_of_range& e) {
17782       {
17783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17784       };
17785     } catch (std::exception& e) {
17786       {
17787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17788       };
17789     } catch (Dali::DaliException e) {
17790       {
17791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17796       };
17797     }
17798   }
17799
17800   jresult = result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17806   unsigned int jresult ;
17807   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17808   std::string *arg2 = 0 ;
17809   bool result;
17810
17811   arg1 = (Dali::Property::Value *)jarg1;
17812
17813   //typemap in
17814   std::string temp;
17815   arg2 = &temp;
17816
17817   {
17818     try {
17819       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (Dali::DaliException e) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17831       };
17832     } catch (...) {
17833       {
17834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17835       };
17836     }
17837   }
17838
17839   jresult = result;
17840
17841   //Typemap argout in c++ file.
17842   //This will convert c++ string to c# string
17843   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17844
17845   return jresult;
17846 }
17847
17848
17849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17850   unsigned int jresult ;
17851   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17852   Dali::Property::Array *arg2 = 0 ;
17853   bool result;
17854
17855   arg1 = (Dali::Property::Value *)jarg1;
17856   arg2 = (Dali::Property::Array *)jarg2;
17857   if (!arg2) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17859     return 0;
17860   }
17861   {
17862     try {
17863       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17864     } catch (std::out_of_range& e) {
17865       {
17866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17867       };
17868     } catch (std::exception& e) {
17869       {
17870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17871       };
17872     } catch (Dali::DaliException e) {
17873       {
17874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17875       };
17876     } catch (...) {
17877       {
17878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17879       };
17880     }
17881   }
17882
17883   jresult = result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17889   unsigned int jresult ;
17890   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17891   Dali::Property::Map *arg2 = 0 ;
17892   bool result;
17893
17894   arg1 = (Dali::Property::Value *)jarg1;
17895   arg2 = (Dali::Property::Map *)jarg2;
17896   if (!arg2) {
17897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17898     return 0;
17899   }
17900   {
17901     try {
17902       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17903     } catch (std::out_of_range& e) {
17904       {
17905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (std::exception& e) {
17908       {
17909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17910       };
17911     } catch (Dali::DaliException e) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17914       };
17915     } catch (...) {
17916       {
17917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17918       };
17919     }
17920   }
17921
17922   jresult = result;
17923   return jresult;
17924 }
17925
17926
17927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17928   unsigned int jresult ;
17929   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17930   Extents *arg2 = 0 ;
17931   bool result;
17932
17933   arg1 = (Dali::Property::Value *)jarg1;
17934   arg2 = (Extents *)jarg2;
17935   if (!arg2) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17962   void * jresult ;
17963   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17964   Dali::Property::Array *result = 0 ;
17965
17966   arg1 = (Dali::Property::Value *)jarg1;
17967   {
17968     try {
17969       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17970     } catch (std::out_of_range& e) {
17971       {
17972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (std::exception& e) {
17975       {
17976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (Dali::DaliException e) {
17979       {
17980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988
17989   jresult = (void *)result;
17990   return jresult;
17991 }
17992
17993
17994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17995   void * jresult ;
17996   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17997   Dali::Property::Map *result = 0 ;
17998
17999   arg1 = (Dali::Property::Value *)jarg1;
18000   {
18001     try {
18002       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18003     } catch (std::out_of_range& e) {
18004       {
18005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (std::exception& e) {
18008       {
18009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (Dali::DaliException e) {
18012       {
18013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021
18022   jresult = (void *)result;
18023   return jresult;
18024 }
18025
18026
18027 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18028   char * jresult ;
18029   Dali::Property::Type arg1 ;
18030   char *result = 0 ;
18031
18032   arg1 = (Dali::Property::Type)jarg1;
18033   {
18034     try {
18035       result = (char *)Dali::PropertyTypes::GetName(arg1);
18036     } catch (std::out_of_range& e) {
18037       {
18038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (std::exception& e) {
18041       {
18042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (Dali::DaliException e) {
18045       {
18046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054
18055   jresult = SWIG_csharp_string_callback((const char *)result);
18056   return jresult;
18057 }
18058
18059
18060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18061   unsigned int jresult ;
18062   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18063   std::string *arg2 = 0 ;
18064   Dali::Property::Map *arg3 = 0 ;
18065   bool result;
18066
18067   arg1 = (Dali::BaseObject *)jarg1;
18068   if (!jarg2) {
18069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18070     return 0;
18071   }
18072   std::string arg2_str(jarg2);
18073   arg2 = &arg2_str;
18074   arg3 = (Dali::Property::Map *)jarg3;
18075   if (!arg3) {
18076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18077     return 0;
18078   }
18079   {
18080     try {
18081       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (Dali::DaliException e) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18093       };
18094     } catch (...) {
18095       {
18096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18097       };
18098     }
18099   }
18100
18101   jresult = result;
18102
18103   //argout typemap for const std::string&
18104
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18110   char * jresult ;
18111   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18112   std::string *result = 0 ;
18113
18114   arg1 = (Dali::BaseObject *)jarg1;
18115   {
18116     try {
18117       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18118     } catch (std::out_of_range& e) {
18119       {
18120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18121       };
18122     } catch (std::exception& e) {
18123       {
18124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18125       };
18126     } catch (Dali::DaliException e) {
18127       {
18128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18129       };
18130     } catch (...) {
18131       {
18132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18133       };
18134     }
18135   }
18136
18137   jresult = SWIG_csharp_string_callback(result->c_str());
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18143   unsigned int jresult ;
18144   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18145   Dali::TypeInfo *arg2 = 0 ;
18146   bool result;
18147
18148   arg1 = (Dali::BaseObject *)jarg1;
18149   arg2 = (Dali::TypeInfo *)jarg2;
18150   if (!arg2) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18182   unsigned int jresult ;
18183   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18184   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18185   std::string *arg3 = 0 ;
18186   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18187   bool result;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   arg2 = (ConnectionTrackerInterface *)jarg2;
18191   if (!jarg3) {
18192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18193     return 0;
18194   }
18195   std::string arg3_str(jarg3);
18196   arg3 = &arg3_str;
18197   arg4 = (FunctorDelegate *)jarg4;
18198   {
18199     try {
18200       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18201     } catch (std::out_of_range& e) {
18202       {
18203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18204       };
18205     } catch (std::exception& e) {
18206       {
18207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18208       };
18209     } catch (Dali::DaliException e) {
18210       {
18211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18212       };
18213     } catch (...) {
18214       {
18215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18216       };
18217     }
18218   }
18219
18220   jresult = result;
18221
18222   //argout typemap for const std::string&
18223
18224   return jresult;
18225 }
18226
18227
18228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18229   void * jresult ;
18230   Dali::BaseHandle *arg1 = 0 ;
18231   Dali::BaseObject *result = 0 ;
18232
18233   arg1 = (Dali::BaseHandle *)jarg1;
18234   if (!arg1) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18236     return 0;
18237   }
18238   {
18239     try {
18240       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18241     } catch (std::out_of_range& e) {
18242       {
18243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18244       };
18245     } catch (std::exception& e) {
18246       {
18247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18248       };
18249     } catch (Dali::DaliException e) {
18250       {
18251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18252       };
18253     } catch (...) {
18254       {
18255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18256       };
18257     }
18258   }
18259
18260   jresult = (void *)result;
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18268   Dali::BaseHandle *result = 0 ;
18269
18270   arg1 = (Dali::BaseObject *)jarg1;
18271   {
18272     try {
18273       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18274     } catch (std::out_of_range& e) {
18275       {
18276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (std::exception& e) {
18279       {
18280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (Dali::DaliException e) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18285       };
18286     } catch (...) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18289       };
18290     }
18291   }
18292
18293   jresult = (void *)result;
18294   return jresult;
18295 }
18296
18297
18298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18299   void * jresult ;
18300   Dali::BaseHandle *result = 0 ;
18301
18302   {
18303     try {
18304       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18305     } catch (std::out_of_range& e) {
18306       {
18307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18308       };
18309     } catch (std::exception& e) {
18310       {
18311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (Dali::DaliException e) {
18314       {
18315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323
18324   jresult = (void *)result;
18325   return jresult;
18326 }
18327
18328
18329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18330   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18331
18332   arg1 = (Dali::BaseHandle *)jarg1;
18333   {
18334     try {
18335       delete arg1;
18336     } catch (std::out_of_range& e) {
18337       {
18338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18339       };
18340     } catch (std::exception& e) {
18341       {
18342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18343       };
18344     } catch (Dali::DaliException e) {
18345       {
18346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18347       };
18348     } catch (...) {
18349       {
18350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18351       };
18352     }
18353   }
18354
18355 }
18356
18357
18358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18359   void * jresult ;
18360   Dali::BaseHandle *arg1 = 0 ;
18361   Dali::BaseHandle *result = 0 ;
18362
18363   arg1 = (Dali::BaseHandle *)jarg1;
18364   if (!arg1) {
18365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18366     return 0;
18367   }
18368   {
18369     try {
18370       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18371     } catch (std::out_of_range& e) {
18372       {
18373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (std::exception& e) {
18376       {
18377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18378       };
18379     } catch (Dali::DaliException e) {
18380       {
18381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18382       };
18383     } catch (...) {
18384       {
18385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18386       };
18387     }
18388   }
18389
18390   jresult = (void *)result;
18391   return jresult;
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18398   Dali::BaseHandle *arg2 = 0 ;
18399   Dali::BaseHandle *result = 0 ;
18400
18401   arg1 = (Dali::BaseHandle *)jarg1;
18402   arg2 = (Dali::BaseHandle *)jarg2;
18403   if (!arg2) {
18404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18405     return 0;
18406   }
18407   {
18408     try {
18409       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18410     } catch (std::out_of_range& e) {
18411       {
18412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18413       };
18414     } catch (std::exception& e) {
18415       {
18416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18417       };
18418     } catch (Dali::DaliException e) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18421       };
18422     } catch (...) {
18423       {
18424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18425       };
18426     }
18427   }
18428
18429   jresult = (void *)result;
18430   return jresult;
18431 }
18432
18433
18434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18435   unsigned int jresult ;
18436   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18437   std::string *arg2 = 0 ;
18438   Dali::Property::Map *arg3 = 0 ;
18439   bool result;
18440
18441   arg1 = (Dali::BaseHandle *)jarg1;
18442   if (!jarg2) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18444     return 0;
18445   }
18446   std::string arg2_str(jarg2);
18447   arg2 = &arg2_str;
18448   arg3 = (Dali::Property::Map *)jarg3;
18449   if (!arg3) {
18450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18451     return 0;
18452   }
18453   {
18454     try {
18455       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18471       };
18472     }
18473   }
18474
18475   jresult = result;
18476
18477   //argout typemap for const std::string&
18478
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18484   char * jresult ;
18485   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18486   std::string *result = 0 ;
18487
18488   arg1 = (Dali::BaseHandle *)jarg1;
18489   {
18490     try {
18491       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18492     } catch (std::out_of_range& e) {
18493       {
18494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18495       };
18496     } catch (std::exception& e) {
18497       {
18498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (Dali::DaliException e) {
18501       {
18502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510
18511   jresult = SWIG_csharp_string_callback(result->c_str());
18512   return jresult;
18513 }
18514
18515
18516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18517   unsigned int jresult ;
18518   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18519   Dali::TypeInfo *arg2 = 0 ;
18520   bool result;
18521
18522   arg1 = (Dali::BaseHandle *)jarg1;
18523   arg2 = (Dali::TypeInfo *)jarg2;
18524   if (!arg2) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18556   void * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   Dali::BaseObject *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = (void *)result;
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18589   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18590
18591   arg1 = (Dali::BaseHandle *)jarg1;
18592   {
18593     try {
18594       (arg1)->Reset();
18595     } catch (std::out_of_range& e) {
18596       {
18597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18598       };
18599     } catch (std::exception& e) {
18600       {
18601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18602       };
18603     } catch (Dali::DaliException e) {
18604       {
18605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18606       };
18607     } catch (...) {
18608       {
18609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18610       };
18611     }
18612   }
18613
18614 }
18615
18616
18617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18618   unsigned int jresult ;
18619   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18620   Dali::BaseHandle *arg2 = 0 ;
18621   bool result;
18622
18623   arg1 = (Dali::BaseHandle *)jarg1;
18624   arg2 = (Dali::BaseHandle *)jarg2;
18625   if (!arg2) {
18626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18627     return 0;
18628   }
18629   {
18630     try {
18631       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18647       };
18648     }
18649   }
18650
18651   jresult = result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18657   unsigned int jresult ;
18658   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18659   Dali::BaseHandle *arg2 = 0 ;
18660   bool result;
18661
18662   arg1 = (Dali::BaseHandle *)jarg1;
18663   arg2 = (Dali::BaseHandle *)jarg2;
18664   if (!arg2) {
18665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18666     return 0;
18667   }
18668   {
18669     try {
18670       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18671     } catch (std::out_of_range& e) {
18672       {
18673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18674       };
18675     } catch (std::exception& e) {
18676       {
18677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18678       };
18679     } catch (Dali::DaliException e) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18682       };
18683     } catch (...) {
18684       {
18685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18686       };
18687     }
18688   }
18689
18690   jresult = result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18696   void * jresult ;
18697   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18698   Dali::RefObject *result = 0 ;
18699
18700   arg1 = (Dali::BaseHandle *)jarg1;
18701   {
18702     try {
18703       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (Dali::DaliException e) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722
18723   jresult = (void *)result;
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18729   unsigned int jresult ;
18730   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18731   bool result;
18732
18733   arg1 = (Dali::BaseHandle *)jarg1;
18734   {
18735     try {
18736       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18737     } catch (std::out_of_range& e) {
18738       {
18739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18740       };
18741     } catch (std::exception& e) {
18742       {
18743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (Dali::DaliException e) {
18746       {
18747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18748       };
18749     } catch (...) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18752       };
18753     }
18754   }
18755
18756   jresult = result;
18757   return jresult;
18758 }
18759
18760
18761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18762   unsigned int jresult ;
18763   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18764   Dali::BaseHandle *arg2 = 0 ;
18765   bool result;
18766
18767   arg1 = (Dali::BaseHandle *)jarg1;
18768   arg2 = (Dali::BaseHandle *)jarg2;
18769   if (!arg2) {
18770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18771     return 0;
18772   }
18773   {
18774     try {
18775       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18776     } catch (std::out_of_range& e) {
18777       {
18778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18779       };
18780     } catch (std::exception& e) {
18781       {
18782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (Dali::DaliException e) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794
18795   jresult = result;
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18801   unsigned int jresult ;
18802   Dali::BaseHandle *arg1 = 0 ;
18803   Dali::BaseHandle *arg2 = 0 ;
18804   bool result;
18805
18806   arg1 = (Dali::BaseHandle *)jarg1;
18807   if (!arg1) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   arg2 = (Dali::BaseHandle *)jarg2;
18812   if (!arg2) {
18813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18814     return 0;
18815   }
18816   {
18817     try {
18818       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (Dali::DaliException e) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18830       };
18831     } catch (...) {
18832       {
18833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18834       };
18835     }
18836   }
18837
18838   jresult = result;
18839   return jresult;
18840 }
18841
18842
18843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18844   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18845
18846   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18847   {
18848     try {
18849       delete arg1;
18850     } catch (std::out_of_range& e) {
18851       {
18852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18853       };
18854     } catch (std::exception& e) {
18855       {
18856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18857       };
18858     } catch (Dali::DaliException e) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18865       };
18866     }
18867   }
18868
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18873   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18874   SlotObserver *arg2 = (SlotObserver *) 0 ;
18875   CallbackBase *arg3 = (CallbackBase *) 0 ;
18876
18877   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18878   arg2 = (SlotObserver *)jarg2;
18879   arg3 = (CallbackBase *)jarg3;
18880   {
18881     try {
18882       (arg1)->SignalConnected(arg2,arg3);
18883     } catch (std::out_of_range& e) {
18884       {
18885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18886       };
18887     } catch (std::exception& e) {
18888       {
18889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (Dali::DaliException e) {
18892       {
18893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901
18902 }
18903
18904
18905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18906   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18907
18908   arg1 = (Dali::SignalObserver *)jarg1;
18909   {
18910     try {
18911       delete arg1;
18912     } catch (std::out_of_range& e) {
18913       {
18914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18915       };
18916     } catch (std::exception& e) {
18917       {
18918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18919       };
18920     } catch (Dali::DaliException e) {
18921       {
18922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18923       };
18924     } catch (...) {
18925       {
18926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18927       };
18928     }
18929   }
18930
18931 }
18932
18933
18934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18935   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18936   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18937   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18938
18939   arg1 = (Dali::SignalObserver *)jarg1;
18940   arg2 = (Dali::SlotObserver *)jarg2;
18941   arg3 = (Dali::CallbackBase *)jarg3;
18942   {
18943     try {
18944       (arg1)->SignalDisconnected(arg2,arg3);
18945     } catch (std::out_of_range& e) {
18946       {
18947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18948       };
18949     } catch (std::exception& e) {
18950       {
18951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (Dali::DaliException e) {
18954       {
18955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18956       };
18957     } catch (...) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18960       };
18961     }
18962   }
18963
18964 }
18965
18966
18967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18968   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18969
18970   arg1 = (Dali::SlotObserver *)jarg1;
18971   {
18972     try {
18973       delete arg1;
18974     } catch (std::out_of_range& e) {
18975       {
18976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18977       };
18978     } catch (std::exception& e) {
18979       {
18980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18981       };
18982     } catch (Dali::DaliException e) {
18983       {
18984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18985       };
18986     } catch (...) {
18987       {
18988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18989       };
18990     }
18991   }
18992
18993 }
18994
18995
18996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18997   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18998   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18999
19000   arg1 = (Dali::SlotObserver *)jarg1;
19001   arg2 = (Dali::CallbackBase *)jarg2;
19002   {
19003     try {
19004       (arg1)->SlotDisconnected(arg2);
19005     } catch (std::out_of_range& e) {
19006       {
19007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19008       };
19009     } catch (std::exception& e) {
19010       {
19011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19012       };
19013     } catch (Dali::DaliException e) {
19014       {
19015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19016       };
19017     } catch (...) {
19018       {
19019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19020       };
19021     }
19022   }
19023
19024 }
19025
19026
19027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19028   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19029
19030   arg1 = (Dali::ConnectionTracker *)jarg1;
19031   {
19032     try {
19033       delete arg1;
19034     } catch (std::out_of_range& e) {
19035       {
19036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19037       };
19038     } catch (std::exception& e) {
19039       {
19040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19041       };
19042     } catch (Dali::DaliException e) {
19043       {
19044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19045       };
19046     } catch (...) {
19047       {
19048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19049       };
19050     }
19051   }
19052
19053 }
19054
19055
19056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19057   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19058
19059   arg1 = (Dali::ConnectionTracker *)jarg1;
19060   {
19061     try {
19062       (arg1)->DisconnectAll();
19063     } catch (std::out_of_range& e) {
19064       {
19065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (std::exception& e) {
19068       {
19069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19070       };
19071     } catch (Dali::DaliException e) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19078       };
19079     }
19080   }
19081
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19086   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19087   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19088   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19089
19090   arg1 = (Dali::ConnectionTracker *)jarg1;
19091   arg2 = (Dali::SlotObserver *)jarg2;
19092   arg3 = (Dali::CallbackBase *)jarg3;
19093   {
19094     try {
19095       (arg1)->SignalConnected(arg2,arg3);
19096     } catch (std::out_of_range& e) {
19097       {
19098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (std::exception& e) {
19101       {
19102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (Dali::DaliException e) {
19105       {
19106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19111       };
19112     }
19113   }
19114
19115 }
19116
19117
19118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19119   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19120   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19121   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19122
19123   arg1 = (Dali::ConnectionTracker *)jarg1;
19124   arg2 = (Dali::SlotObserver *)jarg2;
19125   arg3 = (Dali::CallbackBase *)jarg3;
19126   {
19127     try {
19128       (arg1)->SignalDisconnected(arg2,arg3);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (Dali::DaliException e) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19140       };
19141     } catch (...) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19144       };
19145     }
19146   }
19147
19148 }
19149
19150
19151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19152   unsigned long jresult ;
19153   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19154   std::size_t result;
19155
19156   arg1 = (Dali::ConnectionTracker *)jarg1;
19157   {
19158     try {
19159       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19160     } catch (std::out_of_range& e) {
19161       {
19162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (std::exception& e) {
19165       {
19166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19167       };
19168     } catch (Dali::DaliException e) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19171       };
19172     } catch (...) {
19173       {
19174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19175       };
19176     }
19177   }
19178
19179   jresult = (unsigned long)result;
19180   return jresult;
19181 }
19182
19183
19184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19185   void * jresult ;
19186   Dali::ObjectRegistry *result = 0 ;
19187
19188   {
19189     try {
19190       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (Dali::DaliException e) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19202       };
19203     } catch (...) {
19204       {
19205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19206       };
19207     }
19208   }
19209
19210   jresult = (void *)result;
19211   return jresult;
19212 }
19213
19214
19215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19216   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19217
19218   arg1 = (Dali::ObjectRegistry *)jarg1;
19219   {
19220     try {
19221       delete arg1;
19222     } catch (std::out_of_range& e) {
19223       {
19224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19225       };
19226     } catch (std::exception& e) {
19227       {
19228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19229       };
19230     } catch (Dali::DaliException e) {
19231       {
19232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19237       };
19238     }
19239   }
19240
19241 }
19242
19243
19244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19245   void * jresult ;
19246   Dali::ObjectRegistry *arg1 = 0 ;
19247   Dali::ObjectRegistry *result = 0 ;
19248
19249   arg1 = (Dali::ObjectRegistry *)jarg1;
19250   if (!arg1) {
19251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19252     return 0;
19253   }
19254   {
19255     try {
19256       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (Dali::DaliException e) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275
19276   jresult = (void *)result;
19277   return jresult;
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19284   Dali::ObjectRegistry *arg2 = 0 ;
19285   Dali::ObjectRegistry *result = 0 ;
19286
19287   arg1 = (Dali::ObjectRegistry *)jarg1;
19288   arg2 = (Dali::ObjectRegistry *)jarg2;
19289   if (!arg2) {
19290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19291     return 0;
19292   }
19293   {
19294     try {
19295       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (Dali::DaliException e) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19307       };
19308     } catch (...) {
19309       {
19310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19311       };
19312     }
19313   }
19314
19315   jresult = (void *)result;
19316   return jresult;
19317 }
19318
19319
19320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19321   void * jresult ;
19322   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19323   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19324
19325   arg1 = (Dali::ObjectRegistry *)jarg1;
19326   {
19327     try {
19328       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19329     } catch (std::out_of_range& e) {
19330       {
19331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19332       };
19333     } catch (std::exception& e) {
19334       {
19335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (Dali::DaliException e) {
19338       {
19339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19340       };
19341     } catch (...) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19344       };
19345     }
19346   }
19347
19348   jresult = (void *)result;
19349   return jresult;
19350 }
19351
19352
19353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19354   void * jresult ;
19355   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19356   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19357
19358   arg1 = (Dali::ObjectRegistry *)jarg1;
19359   {
19360     try {
19361       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19362     } catch (std::out_of_range& e) {
19363       {
19364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19365       };
19366     } catch (std::exception& e) {
19367       {
19368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (Dali::DaliException e) {
19371       {
19372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19373       };
19374     } catch (...) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19377       };
19378     }
19379   }
19380
19381   jresult = (void *)result;
19382   return jresult;
19383 }
19384
19385
19386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19387   void * jresult ;
19388   Dali::PropertyCondition *result = 0 ;
19389
19390   {
19391     try {
19392       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19393     } catch (std::out_of_range& e) {
19394       {
19395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19396       };
19397     } catch (std::exception& e) {
19398       {
19399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (Dali::DaliException e) {
19402       {
19403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411
19412   jresult = (void *)result;
19413   return jresult;
19414 }
19415
19416
19417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19418   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19419
19420   arg1 = (Dali::PropertyCondition *)jarg1;
19421   {
19422     try {
19423       delete arg1;
19424     } catch (std::out_of_range& e) {
19425       {
19426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19427       };
19428     } catch (std::exception& e) {
19429       {
19430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19431       };
19432     } catch (Dali::DaliException e) {
19433       {
19434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19435       };
19436     } catch (...) {
19437       {
19438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19439       };
19440     }
19441   }
19442
19443 }
19444
19445
19446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19447   void * jresult ;
19448   Dali::PropertyCondition *arg1 = 0 ;
19449   Dali::PropertyCondition *result = 0 ;
19450
19451   arg1 = (Dali::PropertyCondition *)jarg1;
19452   if (!arg1) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19454     return 0;
19455   }
19456   {
19457     try {
19458       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19459     } catch (std::out_of_range& e) {
19460       {
19461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19462       };
19463     } catch (std::exception& e) {
19464       {
19465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (Dali::DaliException e) {
19468       {
19469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19470       };
19471     } catch (...) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19474       };
19475     }
19476   }
19477
19478   jresult = (void *)result;
19479   return jresult;
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19486   Dali::PropertyCondition *arg2 = 0 ;
19487   Dali::PropertyCondition *result = 0 ;
19488
19489   arg1 = (Dali::PropertyCondition *)jarg1;
19490   arg2 = (Dali::PropertyCondition *)jarg2;
19491   if (!arg2) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19493     return 0;
19494   }
19495   {
19496     try {
19497       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19498     } catch (std::out_of_range& e) {
19499       {
19500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19501       };
19502     } catch (std::exception& e) {
19503       {
19504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19505       };
19506     } catch (Dali::DaliException e) {
19507       {
19508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19513       };
19514     }
19515   }
19516
19517   jresult = (void *)result;
19518   return jresult;
19519 }
19520
19521
19522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19523   unsigned long jresult ;
19524   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19525   std::size_t result;
19526
19527   arg1 = (Dali::PropertyCondition *)jarg1;
19528   {
19529     try {
19530       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19531     } catch (std::out_of_range& e) {
19532       {
19533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19534       };
19535     } catch (std::exception& e) {
19536       {
19537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (...) {
19540       {
19541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19542       };
19543     }
19544   }
19545   jresult = (unsigned long)result;
19546   return jresult;
19547 }
19548
19549
19550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19551   float jresult ;
19552   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19553   std::size_t arg2 ;
19554   float result;
19555
19556   arg1 = (Dali::PropertyCondition *)jarg1;
19557   arg2 = (std::size_t)jarg2;
19558   {
19559     try {
19560       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19561     } catch (std::out_of_range& e) {
19562       {
19563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19564       };
19565     } catch (std::exception& e) {
19566       {
19567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19568       };
19569     } catch (...) {
19570       {
19571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19572       };
19573     }
19574   }
19575   jresult = result;
19576   return jresult;
19577 }
19578
19579
19580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19581   void * jresult ;
19582   float arg1 ;
19583   Dali::PropertyCondition result;
19584
19585   arg1 = (float)jarg1;
19586   {
19587     try {
19588       result = Dali::LessThanCondition(arg1);
19589     } catch (std::out_of_range& e) {
19590       {
19591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (std::exception& e) {
19594       {
19595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19596       };
19597     } catch (Dali::DaliException e) {
19598       {
19599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19600       };
19601     } catch (...) {
19602       {
19603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19604       };
19605     }
19606   }
19607
19608   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19609   return jresult;
19610 }
19611
19612
19613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19614   void * jresult ;
19615   float arg1 ;
19616   Dali::PropertyCondition result;
19617
19618   arg1 = (float)jarg1;
19619   {
19620     try {
19621       result = Dali::GreaterThanCondition(arg1);
19622     } catch (std::out_of_range& e) {
19623       {
19624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (std::exception& e) {
19627       {
19628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (Dali::DaliException e) {
19631       {
19632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19633       };
19634     } catch (...) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19637       };
19638     }
19639   }
19640
19641   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19642   return jresult;
19643 }
19644
19645
19646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19647   void * jresult ;
19648   float arg1 ;
19649   float arg2 ;
19650   Dali::PropertyCondition result;
19651
19652   arg1 = (float)jarg1;
19653   arg2 = (float)jarg2;
19654   {
19655     try {
19656       result = Dali::InsideCondition(arg1,arg2);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (Dali::DaliException e) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19668       };
19669     } catch (...) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19672       };
19673     }
19674   }
19675
19676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19682   void * jresult ;
19683   float arg1 ;
19684   float arg2 ;
19685   Dali::PropertyCondition result;
19686
19687   arg1 = (float)jarg1;
19688   arg2 = (float)jarg2;
19689   {
19690     try {
19691       result = Dali::OutsideCondition(arg1,arg2);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709   }
19710
19711   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19712   return jresult;
19713 }
19714
19715
19716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19717   void * jresult ;
19718   float arg1 ;
19719   float arg2 ;
19720   Dali::PropertyCondition result;
19721
19722   arg1 = (float)jarg1;
19723   arg2 = (float)jarg2;
19724   {
19725     try {
19726       result = Dali::StepCondition(arg1,arg2);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19752   void * jresult ;
19753   float arg1 ;
19754   Dali::PropertyCondition result;
19755
19756   arg1 = (float)jarg1;
19757   {
19758     try {
19759       result = Dali::StepCondition(arg1);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (Dali::DaliException e) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19771       };
19772     } catch (...) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19775       };
19776     }
19777   }
19778
19779   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19780   return jresult;
19781 }
19782
19783
19784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19785   void * jresult ;
19786   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19787   Dali::PropertyCondition result;
19788
19789   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19790   if (!arg1) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19822   void * jresult ;
19823   Dali::PropertyNotification *result = 0 ;
19824
19825   {
19826     try {
19827       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19828     } catch (std::out_of_range& e) {
19829       {
19830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19831       };
19832     } catch (std::exception& e) {
19833       {
19834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (Dali::DaliException e) {
19837       {
19838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19839       };
19840     } catch (...) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19843       };
19844     }
19845   }
19846
19847   jresult = (void *)result;
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19853   void * jresult ;
19854   Dali::BaseHandle arg1 ;
19855   Dali::BaseHandle *argp1 ;
19856   Dali::PropertyNotification result;
19857
19858   argp1 = (Dali::BaseHandle *)jarg1;
19859   if (!argp1) {
19860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19861     return 0;
19862   }
19863   arg1 = *argp1;
19864   {
19865     try {
19866       result = Dali::PropertyNotification::DownCast(arg1);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19882       };
19883     }
19884   }
19885
19886   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19892   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19893
19894   arg1 = (Dali::PropertyNotification *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19913       };
19914     }
19915   }
19916
19917 }
19918
19919
19920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19921   void * jresult ;
19922   Dali::PropertyNotification *arg1 = 0 ;
19923   Dali::PropertyNotification *result = 0 ;
19924
19925   arg1 = (Dali::PropertyNotification *)jarg1;
19926   if (!arg1) {
19927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19928     return 0;
19929   }
19930   {
19931     try {
19932       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19933     } catch (std::out_of_range& e) {
19934       {
19935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (std::exception& e) {
19938       {
19939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (Dali::DaliException e) {
19942       {
19943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19944       };
19945     } catch (...) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19948       };
19949     }
19950   }
19951
19952   jresult = (void *)result;
19953   return jresult;
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19960   Dali::PropertyNotification *arg2 = 0 ;
19961   Dali::PropertyNotification *result = 0 ;
19962
19963   arg1 = (Dali::PropertyNotification *)jarg1;
19964   arg2 = (Dali::PropertyNotification *)jarg2;
19965   if (!arg2) {
19966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19967     return 0;
19968   }
19969   {
19970     try {
19971       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19972     } catch (std::out_of_range& e) {
19973       {
19974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19975       };
19976     } catch (std::exception& e) {
19977       {
19978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19979       };
19980     } catch (Dali::DaliException e) {
19981       {
19982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19983       };
19984     } catch (...) {
19985       {
19986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19987       };
19988     }
19989   }
19990
19991   jresult = (void *)result;
19992   return jresult;
19993 }
19994
19995
19996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19997   void * jresult ;
19998   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19999   Dali::PropertyCondition result;
20000
20001   arg1 = (Dali::PropertyNotification *)jarg1;
20002   {
20003     try {
20004       result = (arg1)->GetCondition();
20005     } catch (std::out_of_range& e) {
20006       {
20007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20008       };
20009     } catch (std::exception& e) {
20010       {
20011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (Dali::DaliException e) {
20014       {
20015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20016       };
20017     } catch (...) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20020       };
20021     }
20022   }
20023
20024   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20030   void * jresult ;
20031   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20032   Dali::Handle result;
20033
20034   arg1 = (Dali::PropertyNotification *)jarg1;
20035   {
20036     try {
20037       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20038     } catch (std::out_of_range& e) {
20039       {
20040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20041       };
20042     } catch (std::exception& e) {
20043       {
20044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (Dali::DaliException e) {
20047       {
20048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20049       };
20050     } catch (...) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20053       };
20054     }
20055   }
20056
20057   jresult = new Dali::Handle((const Dali::Handle &)result);
20058   return jresult;
20059 }
20060
20061
20062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20063   int jresult ;
20064   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20065   Dali::Property::Index result;
20066
20067   arg1 = (Dali::PropertyNotification *)jarg1;
20068   {
20069     try {
20070       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20071     } catch (std::out_of_range& e) {
20072       {
20073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (std::exception& e) {
20076       {
20077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (Dali::DaliException e) {
20080       {
20081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20082       };
20083     } catch (...) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20086       };
20087     }
20088   }
20089
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20096   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20097   Dali::PropertyNotification::NotifyMode arg2 ;
20098
20099   arg1 = (Dali::PropertyNotification *)jarg1;
20100   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20101   {
20102     try {
20103       (arg1)->SetNotifyMode(arg2);
20104     } catch (std::out_of_range& e) {
20105       {
20106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20107       };
20108     } catch (std::exception& e) {
20109       {
20110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20111       };
20112     } catch (Dali::DaliException e) {
20113       {
20114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20115       };
20116     } catch (...) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20119       };
20120     }
20121   }
20122
20123 }
20124
20125
20126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20127   int jresult ;
20128   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20129   Dali::PropertyNotification::NotifyMode result;
20130
20131   arg1 = (Dali::PropertyNotification *)jarg1;
20132   {
20133     try {
20134       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20135     } catch (std::out_of_range& e) {
20136       {
20137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20138       };
20139     } catch (std::exception& e) {
20140       {
20141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20142       };
20143     } catch (Dali::DaliException e) {
20144       {
20145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20146       };
20147     } catch (...) {
20148       {
20149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20150       };
20151     }
20152   }
20153
20154   jresult = (int)result;
20155   return jresult;
20156 }
20157
20158
20159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20160   unsigned int jresult ;
20161   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20162   bool result;
20163
20164   arg1 = (Dali::PropertyNotification *)jarg1;
20165   {
20166     try {
20167       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20168     } catch (std::out_of_range& e) {
20169       {
20170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20171       };
20172     } catch (std::exception& e) {
20173       {
20174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (Dali::DaliException e) {
20177       {
20178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20179       };
20180     } catch (...) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20183       };
20184     }
20185   }
20186
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20193   void * jresult ;
20194   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20195   Dali::PropertyNotifySignalType *result = 0 ;
20196
20197   arg1 = (Dali::PropertyNotification *)jarg1;
20198   {
20199     try {
20200       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20201     } catch (std::out_of_range& e) {
20202       {
20203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20204       };
20205     } catch (std::exception& e) {
20206       {
20207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (Dali::DaliException e) {
20210       {
20211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20212       };
20213     } catch (...) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20216       };
20217     }
20218   }
20219
20220   jresult = (void *)result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20226   void * jresult ;
20227   Dali::Handle *result = 0 ;
20228
20229   {
20230     try {
20231       result = (Dali::Handle *)new Dali::Handle();
20232     } catch (std::out_of_range& e) {
20233       {
20234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20235       };
20236     } catch (std::exception& e) {
20237       {
20238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20239       };
20240     } catch (Dali::DaliException e) {
20241       {
20242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20243       };
20244     } catch (...) {
20245       {
20246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20247       };
20248     }
20249   }
20250
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20257   void * jresult ;
20258   Dali::Handle result;
20259
20260   {
20261     try {
20262       result = Dali::Handle::New();
20263     } catch (std::out_of_range& e) {
20264       {
20265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20266       };
20267     } catch (std::exception& e) {
20268       {
20269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20270       };
20271     } catch (Dali::DaliException e) {
20272       {
20273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20274       };
20275     } catch (...) {
20276       {
20277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20278       };
20279     }
20280   }
20281
20282   jresult = new Dali::Handle((const Dali::Handle &)result);
20283   return jresult;
20284 }
20285
20286
20287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20288   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20289
20290   arg1 = (Dali::Handle *)jarg1;
20291   {
20292     try {
20293       delete arg1;
20294     } catch (std::out_of_range& e) {
20295       {
20296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20297       };
20298     } catch (std::exception& e) {
20299       {
20300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20301       };
20302     } catch (Dali::DaliException e) {
20303       {
20304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20305       };
20306     } catch (...) {
20307       {
20308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20309       };
20310     }
20311   }
20312
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20317   void * jresult ;
20318   Dali::Handle *arg1 = 0 ;
20319   Dali::Handle *result = 0 ;
20320
20321   arg1 = (Dali::Handle *)jarg1;
20322   if (!arg1) {
20323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20324     return 0;
20325   }
20326   {
20327     try {
20328       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20329     } catch (std::out_of_range& e) {
20330       {
20331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20332       };
20333     } catch (std::exception& e) {
20334       {
20335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20336       };
20337     } catch (Dali::DaliException e) {
20338       {
20339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20340       };
20341     } catch (...) {
20342       {
20343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20344       };
20345     }
20346   }
20347
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20356   Dali::Handle *arg2 = 0 ;
20357   Dali::Handle *result = 0 ;
20358
20359   arg1 = (Dali::Handle *)jarg1;
20360   arg2 = (Dali::Handle *)jarg2;
20361   if (!arg2) {
20362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20363     return 0;
20364   }
20365   {
20366     try {
20367       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20368     } catch (std::out_of_range& e) {
20369       {
20370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20371       };
20372     } catch (std::exception& e) {
20373       {
20374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20375       };
20376     } catch (Dali::DaliException e) {
20377       {
20378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20379       };
20380     } catch (...) {
20381       {
20382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20383       };
20384     }
20385   }
20386
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20393   void * jresult ;
20394   Dali::BaseHandle arg1 ;
20395   Dali::BaseHandle *argp1 ;
20396   Dali::Handle result;
20397
20398   argp1 = (Dali::BaseHandle *)jarg1;
20399   if (!argp1) {
20400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20401     return 0;
20402   }
20403   arg1 = *argp1;
20404   {
20405     try {
20406       result = Dali::Handle::DownCast(arg1);
20407     } catch (std::out_of_range& e) {
20408       {
20409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20410       };
20411     } catch (std::exception& e) {
20412       {
20413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20414       };
20415     } catch (Dali::DaliException e) {
20416       {
20417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20418       };
20419     } catch (...) {
20420       {
20421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20422       };
20423     }
20424   }
20425
20426   jresult = new Dali::Handle((const Dali::Handle &)result);
20427   return jresult;
20428 }
20429
20430
20431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20432   unsigned int jresult ;
20433   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20434   Dali::Handle::Capability arg2 ;
20435   bool result;
20436
20437   arg1 = (Dali::Handle *)jarg1;
20438   arg2 = (Dali::Handle::Capability)jarg2;
20439   {
20440     try {
20441       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20442     } catch (std::out_of_range& e) {
20443       {
20444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20445       };
20446     } catch (std::exception& e) {
20447       {
20448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20449       };
20450     } catch (Dali::DaliException e) {
20451       {
20452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20453       };
20454     } catch (...) {
20455       {
20456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20457       };
20458     }
20459   }
20460
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20467   unsigned int jresult ;
20468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20469   unsigned int result;
20470
20471   arg1 = (Dali::Handle *)jarg1;
20472   {
20473     try {
20474       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20475     } catch (std::out_of_range& e) {
20476       {
20477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20478       };
20479     } catch (std::exception& e) {
20480       {
20481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (Dali::DaliException e) {
20484       {
20485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20486       };
20487     } catch (...) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20490       };
20491     }
20492   }
20493
20494   jresult = result;
20495   return jresult;
20496 }
20497
20498
20499 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20500   char * jresult ;
20501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20502   Dali::Property::Index arg2 ;
20503   std::string result;
20504
20505   arg1 = (Dali::Handle *)jarg1;
20506   arg2 = (Dali::Property::Index)jarg2;
20507   {
20508     try {
20509       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20510     } catch (std::out_of_range& e) {
20511       {
20512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20513       };
20514     } catch (std::exception& e) {
20515       {
20516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (Dali::DaliException e) {
20519       {
20520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20521       };
20522     } catch (...) {
20523       {
20524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20525       };
20526     }
20527   }
20528
20529   jresult = SWIG_csharp_string_callback((&result)->c_str());
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20535   int jresult ;
20536   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20537   std::string *arg2 = 0 ;
20538   Dali::Property::Index result;
20539
20540   arg1 = (Dali::Handle *)jarg1;
20541   if (!jarg2) {
20542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20543     return 0;
20544   }
20545   std::string arg2_str(jarg2);
20546   arg2 = &arg2_str;
20547   {
20548     try {
20549       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570
20571   //argout typemap for const std::string&
20572
20573   return jresult;
20574 }
20575
20576
20577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20578   unsigned int jresult ;
20579   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20580   Dali::Property::Index arg2 ;
20581   bool result;
20582
20583   arg1 = (Dali::Handle *)jarg1;
20584   arg2 = (Dali::Property::Index)jarg2;
20585   {
20586     try {
20587       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20588     } catch (std::out_of_range& e) {
20589       {
20590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20591       };
20592     } catch (std::exception& e) {
20593       {
20594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (Dali::DaliException e) {
20597       {
20598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606
20607   jresult = result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20613   unsigned int jresult ;
20614   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20615   Dali::Property::Index arg2 ;
20616   bool result;
20617
20618   arg1 = (Dali::Handle *)jarg1;
20619   arg2 = (Dali::Property::Index)jarg2;
20620   {
20621     try {
20622       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20623     } catch (std::out_of_range& e) {
20624       {
20625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (std::exception& e) {
20628       {
20629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (Dali::DaliException e) {
20632       {
20633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641
20642   jresult = result;
20643   return jresult;
20644 }
20645
20646
20647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20648   unsigned int jresult ;
20649   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20650   Dali::Property::Index arg2 ;
20651   bool result;
20652
20653   arg1 = (Dali::Handle *)jarg1;
20654   arg2 = (Dali::Property::Index)jarg2;
20655   {
20656     try {
20657       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20658     } catch (std::out_of_range& e) {
20659       {
20660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20661       };
20662     } catch (std::exception& e) {
20663       {
20664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (Dali::DaliException e) {
20667       {
20668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20683   int jresult ;
20684   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20685   Dali::Property::Index arg2 ;
20686   Dali::Property::Type result;
20687
20688   arg1 = (Dali::Handle *)jarg1;
20689   arg2 = (Dali::Property::Index)jarg2;
20690   {
20691     try {
20692       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = (int)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20718   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20719   Dali::Property::Index arg2 ;
20720   Dali::Property::Value *arg3 = 0 ;
20721
20722   arg1 = (Dali::Handle *)jarg1;
20723   arg2 = (Dali::Property::Index)jarg2;
20724   arg3 = (Dali::Property::Value *)jarg3;
20725   if (!arg3) {
20726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20727     return ;
20728   }
20729   {
20730     try {
20731       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20732     } catch (std::out_of_range& e) {
20733       {
20734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20735       };
20736     } catch (std::exception& e) {
20737       {
20738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20739       };
20740     } catch (Dali::DaliException e) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20743       };
20744     } catch (...) {
20745       {
20746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20747       };
20748     }
20749   }
20750
20751 }
20752
20753
20754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20755   int jresult ;
20756   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20757   std::string *arg2 = 0 ;
20758   Dali::Property::Value *arg3 = 0 ;
20759   Dali::Property::Index result;
20760
20761   arg1 = (Dali::Handle *)jarg1;
20762   if (!jarg2) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20764     return 0;
20765   }
20766   std::string arg2_str(jarg2);
20767   arg2 = &arg2_str;
20768   arg3 = (Dali::Property::Value *)jarg3;
20769   if (!arg3) {
20770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20771     return 0;
20772   }
20773   {
20774     try {
20775       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (Dali::DaliException e) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20787       };
20788     } catch (...) {
20789       {
20790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20791       };
20792     }
20793   }
20794
20795   jresult = result;
20796
20797   //argout typemap for const std::string&
20798
20799   return jresult;
20800 }
20801
20802
20803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20804   int jresult ;
20805   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20806   std::string *arg2 = 0 ;
20807   Dali::Property::Value *arg3 = 0 ;
20808   Dali::Property::AccessMode arg4 ;
20809   Dali::Property::Index result;
20810
20811   arg1 = (Dali::Handle *)jarg1;
20812   if (!jarg2) {
20813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20814     return 0;
20815   }
20816   std::string arg2_str(jarg2);
20817   arg2 = &arg2_str;
20818   arg3 = (Dali::Property::Value *)jarg3;
20819   if (!arg3) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20821     return 0;
20822   }
20823   arg4 = (Dali::Property::AccessMode)jarg4;
20824   {
20825     try {
20826       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20827     } catch (std::out_of_range& e) {
20828       {
20829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (std::exception& e) {
20832       {
20833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20834       };
20835     } catch (Dali::DaliException e) {
20836       {
20837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20838       };
20839     } catch (...) {
20840       {
20841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20842       };
20843     }
20844   }
20845
20846   jresult = result;
20847
20848   //argout typemap for const std::string&
20849
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20855   void * jresult ;
20856   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20857   Dali::Property::Index arg2 ;
20858   Dali::Property::Value result;
20859
20860   arg1 = (Dali::Handle *)jarg1;
20861   arg2 = (Dali::Property::Index)jarg2;
20862   {
20863     try {
20864       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20865     } catch (std::out_of_range& e) {
20866       {
20867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20868       };
20869     } catch (std::exception& e) {
20870       {
20871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (Dali::DaliException e) {
20874       {
20875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883
20884   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20885   return jresult;
20886 }
20887
20888
20889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20890   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20891   Dali::Property::IndexContainer *arg2 = 0 ;
20892
20893   arg1 = (Dali::Handle *)jarg1;
20894   arg2 = (Dali::Property::IndexContainer *)jarg2;
20895   if (!arg2) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20897     return ;
20898   }
20899   {
20900     try {
20901       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20917       };
20918     }
20919   }
20920
20921 }
20922
20923
20924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20925   void * jresult ;
20926   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20927   Dali::Property::Index arg2 ;
20928   Dali::PropertyCondition *arg3 = 0 ;
20929   Dali::PropertyNotification result;
20930
20931   arg1 = (Dali::Handle *)jarg1;
20932   arg2 = (Dali::Property::Index)jarg2;
20933   arg3 = (Dali::PropertyCondition *)jarg3;
20934   if (!arg3) {
20935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20936     return 0;
20937   }
20938   {
20939     try {
20940       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (Dali::DaliException e) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20956       };
20957     }
20958   }
20959
20960   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20961   return jresult;
20962 }
20963
20964
20965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20966   void * jresult ;
20967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20968   Dali::Property::Index arg2 ;
20969   int arg3 ;
20970   Dali::PropertyCondition *arg4 = 0 ;
20971   Dali::PropertyNotification result;
20972
20973   arg1 = (Dali::Handle *)jarg1;
20974   arg2 = (Dali::Property::Index)jarg2;
20975   arg3 = (int)jarg3;
20976   arg4 = (Dali::PropertyCondition *)jarg4;
20977   if (!arg4) {
20978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20979     return 0;
20980   }
20981   {
20982     try {
20983       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (Dali::DaliException e) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20995       };
20996     } catch (...) {
20997       {
20998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20999       };
21000     }
21001   }
21002
21003   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21004   return jresult;
21005 }
21006
21007
21008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21009   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21010   Dali::PropertyNotification arg2 ;
21011   Dali::PropertyNotification *argp2 ;
21012
21013   arg1 = (Dali::Handle *)jarg1;
21014   argp2 = (Dali::PropertyNotification *)jarg2;
21015   if (!argp2) {
21016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21017     return ;
21018   }
21019   arg2 = *argp2;
21020   {
21021     try {
21022       (arg1)->RemovePropertyNotification(arg2);
21023     } catch (std::out_of_range& e) {
21024       {
21025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21026       };
21027     } catch (std::exception& e) {
21028       {
21029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21030       };
21031     } catch (Dali::DaliException e) {
21032       {
21033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21034       };
21035     } catch (...) {
21036       {
21037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21038       };
21039     }
21040   }
21041
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   {
21050     try {
21051       (arg1)->RemovePropertyNotifications();
21052     } catch (std::out_of_range& e) {
21053       {
21054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21055       };
21056     } catch (std::exception& e) {
21057       {
21058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21059       };
21060     } catch (Dali::DaliException e) {
21061       {
21062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21067       };
21068     }
21069   }
21070
21071 }
21072
21073
21074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21075   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21076
21077   arg1 = (Dali::Handle *)jarg1;
21078   {
21079     try {
21080       (arg1)->RemoveConstraints();
21081     } catch (std::out_of_range& e) {
21082       {
21083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (std::exception& e) {
21086       {
21087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21088       };
21089     } catch (Dali::DaliException e) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21096       };
21097     }
21098   }
21099
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21105   unsigned int arg2 ;
21106
21107   arg1 = (Dali::Handle *)jarg1;
21108   arg2 = (unsigned int)jarg2;
21109   {
21110     try {
21111       (arg1)->RemoveConstraints(arg2);
21112     } catch (std::out_of_range& e) {
21113       {
21114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (std::exception& e) {
21117       {
21118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21119       };
21120     } catch (Dali::DaliException e) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21123       };
21124     } catch (...) {
21125       {
21126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21127       };
21128     }
21129   }
21130
21131 }
21132
21133
21134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21135   int jresult ;
21136   Dali::Property::Index result;
21137
21138   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21139   jresult = result;
21140   return jresult;
21141 }
21142
21143
21144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21145   void * jresult ;
21146   Dali::Handle result;
21147
21148   {
21149     try {
21150       result = Dali::WeightObject::New();
21151     } catch (std::out_of_range& e) {
21152       {
21153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (std::exception& e) {
21156       {
21157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21158       };
21159     } catch (Dali::DaliException e) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21166       };
21167     }
21168   }
21169
21170   jresult = new Dali::Handle((const Dali::Handle &)result);
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21176   void * jresult ;
21177   Dali::TypeInfo *result = 0 ;
21178
21179   {
21180     try {
21181       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21189       };
21190     } catch (Dali::DaliException e) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21193       };
21194     } catch (...) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21197       };
21198     }
21199   }
21200
21201   jresult = (void *)result;
21202   return jresult;
21203 }
21204
21205
21206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21207   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21208
21209   arg1 = (Dali::TypeInfo *)jarg1;
21210   {
21211     try {
21212       delete arg1;
21213     } catch (std::out_of_range& e) {
21214       {
21215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21216       };
21217     } catch (std::exception& e) {
21218       {
21219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21220       };
21221     } catch (Dali::DaliException e) {
21222       {
21223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21228       };
21229     }
21230   }
21231
21232 }
21233
21234
21235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21236   void * jresult ;
21237   Dali::TypeInfo *arg1 = 0 ;
21238   Dali::TypeInfo *result = 0 ;
21239
21240   arg1 = (Dali::TypeInfo *)jarg1;
21241   if (!arg1) {
21242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21243     return 0;
21244   }
21245   {
21246     try {
21247       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (Dali::DaliException e) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266
21267   jresult = (void *)result;
21268   return jresult;
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21275   Dali::TypeInfo *arg2 = 0 ;
21276   Dali::TypeInfo *result = 0 ;
21277
21278   arg1 = (Dali::TypeInfo *)jarg1;
21279   arg2 = (Dali::TypeInfo *)jarg2;
21280   if (!arg2) {
21281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21282     return 0;
21283   }
21284   {
21285     try {
21286       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21287     } catch (std::out_of_range& e) {
21288       {
21289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (std::exception& e) {
21292       {
21293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21294       };
21295     } catch (Dali::DaliException e) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21298       };
21299     } catch (...) {
21300       {
21301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21302       };
21303     }
21304   }
21305
21306   jresult = (void *)result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21312   char * jresult ;
21313   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21314   std::string *result = 0 ;
21315
21316   arg1 = (Dali::TypeInfo *)jarg1;
21317   {
21318     try {
21319       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21320     } catch (std::out_of_range& e) {
21321       {
21322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21323       };
21324     } catch (std::exception& e) {
21325       {
21326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (Dali::DaliException e) {
21329       {
21330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21331       };
21332     } catch (...) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21335       };
21336     }
21337   }
21338
21339   jresult = SWIG_csharp_string_callback(result->c_str());
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21345   char * jresult ;
21346   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21347   std::string *result = 0 ;
21348
21349   arg1 = (Dali::TypeInfo *)jarg1;
21350   {
21351     try {
21352       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (Dali::DaliException e) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21364       };
21365     } catch (...) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21368       };
21369     }
21370   }
21371
21372   jresult = SWIG_csharp_string_callback(result->c_str());
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21378   void * jresult ;
21379   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21380   Dali::BaseHandle result;
21381
21382   arg1 = (Dali::TypeInfo *)jarg1;
21383   {
21384     try {
21385       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21386     } catch (std::out_of_range& e) {
21387       {
21388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (std::exception& e) {
21391       {
21392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (Dali::DaliException e) {
21395       {
21396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21397       };
21398     } catch (...) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21401       };
21402     }
21403   }
21404
21405   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21406   return jresult;
21407 }
21408
21409
21410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21411   unsigned long jresult ;
21412   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21413   size_t result;
21414
21415   arg1 = (Dali::TypeInfo *)jarg1;
21416   {
21417     try {
21418       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21419     } catch (std::out_of_range& e) {
21420       {
21421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21422       };
21423     } catch (std::exception& e) {
21424       {
21425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (Dali::DaliException e) {
21428       {
21429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21430       };
21431     } catch (...) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21434       };
21435     }
21436   }
21437
21438   jresult = (unsigned long)result;
21439   return jresult;
21440 }
21441
21442
21443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21444   char * jresult ;
21445   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21446   size_t arg2 ;
21447   std::string result;
21448
21449   arg1 = (Dali::TypeInfo *)jarg1;
21450   arg2 = (size_t)jarg2;
21451   {
21452     try {
21453       result = (arg1)->GetActionName(arg2);
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21461       };
21462     } catch (Dali::DaliException e) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21465       };
21466     } catch (...) {
21467       {
21468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21469       };
21470     }
21471   }
21472
21473   jresult = SWIG_csharp_string_callback((&result)->c_str());
21474   return jresult;
21475 }
21476
21477
21478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21479   unsigned long jresult ;
21480   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21481   size_t result;
21482
21483   arg1 = (Dali::TypeInfo *)jarg1;
21484   {
21485     try {
21486       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (Dali::DaliException e) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505
21506   jresult = (unsigned long)result;
21507   return jresult;
21508 }
21509
21510
21511 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21512   char * jresult ;
21513   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21514   size_t arg2 ;
21515   std::string result;
21516
21517   arg1 = (Dali::TypeInfo *)jarg1;
21518   arg2 = (size_t)jarg2;
21519   {
21520     try {
21521       result = (arg1)->GetSignalName(arg2);
21522     } catch (std::out_of_range& e) {
21523       {
21524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (std::exception& e) {
21527       {
21528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (Dali::DaliException e) {
21531       {
21532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21533       };
21534     } catch (...) {
21535       {
21536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21537       };
21538     }
21539   }
21540
21541   jresult = SWIG_csharp_string_callback((&result)->c_str());
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21547   unsigned long jresult ;
21548   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21549   size_t result;
21550
21551   arg1 = (Dali::TypeInfo *)jarg1;
21552   {
21553     try {
21554       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21555     } catch (std::out_of_range& e) {
21556       {
21557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21558       };
21559     } catch (std::exception& e) {
21560       {
21561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (Dali::DaliException e) {
21564       {
21565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21566       };
21567     } catch (...) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21570       };
21571     }
21572   }
21573
21574   jresult = (unsigned long)result;
21575   return jresult;
21576 }
21577
21578
21579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21580   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21581   Dali::Property::IndexContainer *arg2 = 0 ;
21582
21583   arg1 = (Dali::TypeInfo *)jarg1;
21584   arg2 = (Dali::Property::IndexContainer *)jarg2;
21585   if (!arg2) {
21586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21587     return ;
21588   }
21589   {
21590     try {
21591       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21607       };
21608     }
21609   }
21610
21611 }
21612
21613
21614 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21615   char * jresult ;
21616   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21617   Dali::Property::Index arg2 ;
21618   std::string *result = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::Index)jarg2;
21622   {
21623     try {
21624       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21625     } catch (std::out_of_range& e) {
21626       {
21627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21628       };
21629     } catch (std::exception& e) {
21630       {
21631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21632       };
21633     } catch (Dali::DaliException e) {
21634       {
21635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21636       };
21637     } catch (...) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21640       };
21641     }
21642   }
21643
21644   jresult = SWIG_csharp_string_callback(result->c_str());
21645   return jresult;
21646 }
21647
21648
21649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21650   void * jresult ;
21651   Dali::TypeRegistry result;
21652
21653   {
21654     try {
21655       result = Dali::TypeRegistry::Get();
21656     } catch (std::out_of_range& e) {
21657       {
21658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (std::exception& e) {
21661       {
21662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21663       };
21664     } catch (Dali::DaliException e) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21667       };
21668     } catch (...) {
21669       {
21670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21671       };
21672     }
21673   }
21674
21675   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21676   return jresult;
21677 }
21678
21679
21680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21681   void * jresult ;
21682   Dali::TypeRegistry *result = 0 ;
21683
21684   {
21685     try {
21686       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21687     } catch (std::out_of_range& e) {
21688       {
21689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21690       };
21691     } catch (std::exception& e) {
21692       {
21693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21694       };
21695     } catch (Dali::DaliException e) {
21696       {
21697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21698       };
21699     } catch (...) {
21700       {
21701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21702       };
21703     }
21704   }
21705
21706   jresult = (void *)result;
21707   return jresult;
21708 }
21709
21710
21711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21712   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21713
21714   arg1 = (Dali::TypeRegistry *)jarg1;
21715   {
21716     try {
21717       delete arg1;
21718     } catch (std::out_of_range& e) {
21719       {
21720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21721       };
21722     } catch (std::exception& e) {
21723       {
21724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (Dali::DaliException e) {
21727       {
21728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736
21737 }
21738
21739
21740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21741   void * jresult ;
21742   Dali::TypeRegistry *arg1 = 0 ;
21743   Dali::TypeRegistry *result = 0 ;
21744
21745   arg1 = (Dali::TypeRegistry *)jarg1;
21746   if (!arg1) {
21747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21748     return 0;
21749   }
21750   {
21751     try {
21752       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (Dali::DaliException e) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21764       };
21765     } catch (...) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21768       };
21769     }
21770   }
21771
21772   jresult = (void *)result;
21773   return jresult;
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21780   Dali::TypeRegistry *arg2 = 0 ;
21781   Dali::TypeRegistry *result = 0 ;
21782
21783   arg1 = (Dali::TypeRegistry *)jarg1;
21784   arg2 = (Dali::TypeRegistry *)jarg2;
21785   if (!arg2) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (Dali::DaliException e) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810
21811   jresult = (void *)result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21817   void * jresult ;
21818   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21819   std::string *arg2 = 0 ;
21820   Dali::TypeInfo result;
21821
21822   arg1 = (Dali::TypeRegistry *)jarg1;
21823   if (!jarg2) {
21824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21825     return 0;
21826   }
21827   std::string arg2_str(jarg2);
21828   arg2 = &arg2_str;
21829   {
21830     try {
21831       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21832     } catch (std::out_of_range& e) {
21833       {
21834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (std::exception& e) {
21837       {
21838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (Dali::DaliException e) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21843       };
21844     } catch (...) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21847       };
21848     }
21849   }
21850
21851   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21852
21853   //argout typemap for const std::string&
21854
21855   return jresult;
21856 }
21857
21858
21859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21860   void * jresult ;
21861   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21862   std::type_info *arg2 = 0 ;
21863   Dali::TypeInfo result;
21864
21865   arg1 = (Dali::TypeRegistry *)jarg1;
21866   arg2 = (std::type_info *)jarg2;
21867   if (!arg2) {
21868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21869     return 0;
21870   }
21871   {
21872     try {
21873       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21874     } catch (std::out_of_range& e) {
21875       {
21876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21877       };
21878     } catch (std::exception& e) {
21879       {
21880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (Dali::DaliException e) {
21883       {
21884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21885       };
21886     } catch (...) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21889       };
21890     }
21891   }
21892
21893   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21899   unsigned long jresult ;
21900   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21901   size_t result;
21902
21903   arg1 = (Dali::TypeRegistry *)jarg1;
21904   {
21905     try {
21906       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = (unsigned long)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21932   char * jresult ;
21933   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21934   size_t arg2 ;
21935   std::string result;
21936
21937   arg1 = (Dali::TypeRegistry *)jarg1;
21938   arg2 = (size_t)jarg2;
21939   {
21940     try {
21941       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21942     } catch (std::out_of_range& e) {
21943       {
21944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21945       };
21946     } catch (std::exception& e) {
21947       {
21948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (Dali::DaliException e) {
21951       {
21952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960
21961   jresult = SWIG_csharp_string_callback((&result)->c_str());
21962   return jresult;
21963 }
21964
21965
21966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21967   void * jresult ;
21968   std::type_info *arg1 = 0 ;
21969   std::type_info *arg2 = 0 ;
21970   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21971   Dali::TypeRegistration *result = 0 ;
21972
21973   arg1 = (std::type_info *)jarg1;
21974   if (!arg1) {
21975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21976     return 0;
21977   }
21978   arg2 = (std::type_info *)jarg2;
21979   if (!arg2) {
21980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21981     return 0;
21982   }
21983   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21984   {
21985     try {
21986       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21987     } catch (std::out_of_range& e) {
21988       {
21989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (std::exception& e) {
21992       {
21993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21994       };
21995     } catch (Dali::DaliException e) {
21996       {
21997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22002       };
22003     }
22004   }
22005
22006   jresult = (void *)result;
22007   return jresult;
22008 }
22009
22010
22011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22012   void * jresult ;
22013   std::type_info *arg1 = 0 ;
22014   std::type_info *arg2 = 0 ;
22015   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22016   bool arg4 ;
22017   Dali::TypeRegistration *result = 0 ;
22018
22019   arg1 = (std::type_info *)jarg1;
22020   if (!arg1) {
22021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22022     return 0;
22023   }
22024   arg2 = (std::type_info *)jarg2;
22025   if (!arg2) {
22026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22027     return 0;
22028   }
22029   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22030   arg4 = jarg4 ? true : false;
22031   {
22032     try {
22033       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22034     } catch (std::out_of_range& e) {
22035       {
22036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22037       };
22038     } catch (std::exception& e) {
22039       {
22040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22041       };
22042     } catch (Dali::DaliException e) {
22043       {
22044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22049       };
22050     }
22051   }
22052
22053   jresult = (void *)result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22059   void * jresult ;
22060   std::string *arg1 = 0 ;
22061   std::type_info *arg2 = 0 ;
22062   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22063   Dali::TypeRegistration *result = 0 ;
22064
22065   if (!jarg1) {
22066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22067     return 0;
22068   }
22069   std::string arg1_str(jarg1);
22070   arg1 = &arg1_str;
22071   arg2 = (std::type_info *)jarg2;
22072   if (!arg2) {
22073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22074     return 0;
22075   }
22076   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22077   {
22078     try {
22079       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22080     } catch (std::out_of_range& e) {
22081       {
22082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22083       };
22084     } catch (std::exception& e) {
22085       {
22086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22087       };
22088     } catch (Dali::DaliException e) {
22089       {
22090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22095       };
22096     }
22097   }
22098
22099   jresult = (void *)result;
22100
22101   //argout typemap for const std::string&
22102
22103   return jresult;
22104 }
22105
22106
22107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22108   char * jresult ;
22109   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22110   std::string result;
22111
22112   arg1 = (Dali::TypeRegistration *)jarg1;
22113   {
22114     try {
22115       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22116     } catch (std::out_of_range& e) {
22117       {
22118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22119       };
22120     } catch (std::exception& e) {
22121       {
22122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22123       };
22124     } catch (Dali::DaliException e) {
22125       {
22126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22127       };
22128     } catch (...) {
22129       {
22130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22131       };
22132     }
22133   }
22134
22135   jresult = SWIG_csharp_string_callback((&result)->c_str());
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22141   std::string *arg1 = 0 ;
22142   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22143
22144   if (!jarg1) {
22145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22146     return ;
22147   }
22148   std::string arg1_str(jarg1);
22149   arg1 = &arg1_str;
22150   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22151   {
22152     try {
22153       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22154     } catch (std::out_of_range& e) {
22155       {
22156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22157       };
22158     } catch (std::exception& e) {
22159       {
22160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (Dali::DaliException e) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22165       };
22166     } catch (...) {
22167       {
22168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22169       };
22170     }
22171   }
22172
22173
22174   //argout typemap for const std::string&
22175
22176 }
22177
22178
22179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22180   std::string *arg1 = 0 ;
22181   std::string *arg2 = 0 ;
22182   int arg3 ;
22183   Dali::Property::Type arg4 ;
22184   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22185   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22186
22187   if (!jarg1) {
22188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22189     return ;
22190   }
22191   std::string arg1_str(jarg1);
22192   arg1 = &arg1_str;
22193   if (!jarg2) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22195     return ;
22196   }
22197   std::string arg2_str(jarg2);
22198   arg2 = &arg2_str;
22199   arg3 = (int)jarg3;
22200   arg4 = (Dali::Property::Type)jarg4;
22201   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22202   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22203   {
22204     try {
22205       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22206     } catch (std::out_of_range& e) {
22207       {
22208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22209       };
22210     } catch (std::exception& e) {
22211       {
22212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22213       };
22214     } catch (Dali::DaliException e) {
22215       {
22216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22217       };
22218     } catch (...) {
22219       {
22220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22221       };
22222     }
22223   }
22224
22225
22226   //argout typemap for const std::string&
22227
22228
22229   //argout typemap for const std::string&
22230
22231 }
22232
22233
22234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22235   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22236
22237   arg1 = (Dali::TypeRegistration *)jarg1;
22238   {
22239     try {
22240       delete arg1;
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22248       };
22249     } catch (Dali::DaliException e) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22256       };
22257     }
22258   }
22259
22260 }
22261
22262
22263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22264   void * jresult ;
22265   Dali::TypeRegistration *arg1 = 0 ;
22266   std::string *arg2 = 0 ;
22267   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22268   Dali::SignalConnectorType *result = 0 ;
22269
22270   arg1 = (Dali::TypeRegistration *)jarg1;
22271   if (!arg1) {
22272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22273     return 0;
22274   }
22275   if (!jarg2) {
22276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22277     return 0;
22278   }
22279   std::string arg2_str(jarg2);
22280   arg2 = &arg2_str;
22281   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22282   {
22283     try {
22284       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22285     } catch (std::out_of_range& e) {
22286       {
22287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22288       };
22289     } catch (std::exception& e) {
22290       {
22291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22292       };
22293     } catch (Dali::DaliException e) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22296       };
22297     } catch (...) {
22298       {
22299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22300       };
22301     }
22302   }
22303
22304   jresult = (void *)result;
22305
22306   //argout typemap for const std::string&
22307
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22313   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22314
22315   arg1 = (Dali::SignalConnectorType *)jarg1;
22316   {
22317     try {
22318       delete arg1;
22319     } catch (std::out_of_range& e) {
22320       {
22321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22322       };
22323     } catch (std::exception& e) {
22324       {
22325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22326       };
22327     } catch (Dali::DaliException e) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22330       };
22331     } catch (...) {
22332       {
22333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22334       };
22335     }
22336   }
22337
22338 }
22339
22340
22341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22342   void * jresult ;
22343   Dali::TypeRegistration *arg1 = 0 ;
22344   std::string *arg2 = 0 ;
22345   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22346   Dali::TypeAction *result = 0 ;
22347
22348   arg1 = (Dali::TypeRegistration *)jarg1;
22349   if (!arg1) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22351     return 0;
22352   }
22353   if (!jarg2) {
22354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22355     return 0;
22356   }
22357   std::string arg2_str(jarg2);
22358   arg2 = &arg2_str;
22359   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22360   {
22361     try {
22362       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22363     } catch (std::out_of_range& e) {
22364       {
22365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22366       };
22367     } catch (std::exception& e) {
22368       {
22369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22370       };
22371     } catch (Dali::DaliException e) {
22372       {
22373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22374       };
22375     } catch (...) {
22376       {
22377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22378       };
22379     }
22380   }
22381
22382   jresult = (void *)result;
22383
22384   //argout typemap for const std::string&
22385
22386   return jresult;
22387 }
22388
22389
22390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22391   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22392
22393   arg1 = (Dali::TypeAction *)jarg1;
22394   {
22395     try {
22396       delete arg1;
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22404       };
22405     } catch (Dali::DaliException e) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22412       };
22413     }
22414   }
22415
22416 }
22417
22418
22419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22420   void * jresult ;
22421   Dali::TypeRegistration *arg1 = 0 ;
22422   std::string *arg2 = 0 ;
22423   Dali::Property::Index arg3 ;
22424   Dali::Property::Type arg4 ;
22425   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22426   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22427   Dali::PropertyRegistration *result = 0 ;
22428
22429   arg1 = (Dali::TypeRegistration *)jarg1;
22430   if (!arg1) {
22431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22432     return 0;
22433   }
22434   if (!jarg2) {
22435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22436     return 0;
22437   }
22438   std::string arg2_str(jarg2);
22439   arg2 = &arg2_str;
22440   arg3 = (Dali::Property::Index)jarg3;
22441   arg4 = (Dali::Property::Type)jarg4;
22442   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22443   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22444   {
22445     try {
22446       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22447     } catch (std::out_of_range& e) {
22448       {
22449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22450       };
22451     } catch (std::exception& e) {
22452       {
22453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (Dali::DaliException e) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465
22466   jresult = (void *)result;
22467
22468   //argout typemap for const std::string&
22469
22470   return jresult;
22471 }
22472
22473
22474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22475   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22476
22477   arg1 = (Dali::PropertyRegistration *)jarg1;
22478   {
22479     try {
22480       delete arg1;
22481     } catch (std::out_of_range& e) {
22482       {
22483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22484       };
22485     } catch (std::exception& e) {
22486       {
22487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (Dali::DaliException e) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499
22500 }
22501
22502
22503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22504   void * jresult ;
22505   Dali::TypeRegistration *arg1 = 0 ;
22506   std::string *arg2 = 0 ;
22507   Dali::Property::Index arg3 ;
22508   Dali::Property::Type arg4 ;
22509   Dali::AnimatablePropertyRegistration *result = 0 ;
22510
22511   arg1 = (Dali::TypeRegistration *)jarg1;
22512   if (!arg1) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22514     return 0;
22515   }
22516   if (!jarg2) {
22517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22518     return 0;
22519   }
22520   std::string arg2_str(jarg2);
22521   arg2 = &arg2_str;
22522   arg3 = (Dali::Property::Index)jarg3;
22523   arg4 = (Dali::Property::Type)jarg4;
22524   {
22525     try {
22526       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22527     } catch (std::out_of_range& e) {
22528       {
22529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22530       };
22531     } catch (std::exception& e) {
22532       {
22533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22534       };
22535     } catch (Dali::DaliException e) {
22536       {
22537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22542       };
22543     }
22544   }
22545
22546   jresult = (void *)result;
22547
22548   //argout typemap for const std::string&
22549
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22555   void * jresult ;
22556   Dali::TypeRegistration *arg1 = 0 ;
22557   std::string *arg2 = 0 ;
22558   Dali::Property::Index arg3 ;
22559   Dali::Property::Value *arg4 = 0 ;
22560   Dali::AnimatablePropertyRegistration *result = 0 ;
22561
22562   arg1 = (Dali::TypeRegistration *)jarg1;
22563   if (!arg1) {
22564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22565     return 0;
22566   }
22567   if (!jarg2) {
22568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22569     return 0;
22570   }
22571   std::string arg2_str(jarg2);
22572   arg2 = &arg2_str;
22573   arg3 = (Dali::Property::Index)jarg3;
22574   arg4 = (Dali::Property::Value *)jarg4;
22575   if (!arg4) {
22576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22577     return 0;
22578   }
22579   {
22580     try {
22581       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22582     } catch (std::out_of_range& e) {
22583       {
22584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (std::exception& e) {
22587       {
22588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22589       };
22590     } catch (Dali::DaliException e) {
22591       {
22592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22593       };
22594     } catch (...) {
22595       {
22596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22597       };
22598     }
22599   }
22600
22601   jresult = (void *)result;
22602
22603   //argout typemap for const std::string&
22604
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22610   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22611
22612   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22613   {
22614     try {
22615       delete arg1;
22616     } catch (std::out_of_range& e) {
22617       {
22618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22619       };
22620     } catch (std::exception& e) {
22621       {
22622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22623       };
22624     } catch (Dali::DaliException e) {
22625       {
22626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22627       };
22628     } catch (...) {
22629       {
22630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22631       };
22632     }
22633   }
22634
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22639   void * jresult ;
22640   Dali::TypeRegistration *arg1 = 0 ;
22641   std::string *arg2 = 0 ;
22642   Dali::Property::Index arg3 ;
22643   Dali::Property::Index arg4 ;
22644   unsigned int arg5 ;
22645   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22646
22647   arg1 = (Dali::TypeRegistration *)jarg1;
22648   if (!arg1) {
22649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22650     return 0;
22651   }
22652   if (!jarg2) {
22653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22654     return 0;
22655   }
22656   std::string arg2_str(jarg2);
22657   arg2 = &arg2_str;
22658   arg3 = (Dali::Property::Index)jarg3;
22659   arg4 = (Dali::Property::Index)jarg4;
22660   arg5 = (unsigned int)jarg5;
22661   {
22662     try {
22663       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22664     } catch (std::out_of_range& e) {
22665       {
22666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22667       };
22668     } catch (std::exception& e) {
22669       {
22670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (Dali::DaliException e) {
22673       {
22674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22675       };
22676     } catch (...) {
22677       {
22678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22679       };
22680     }
22681   }
22682
22683   jresult = (void *)result;
22684
22685   //argout typemap for const std::string&
22686
22687   return jresult;
22688 }
22689
22690
22691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22692   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22693
22694   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22695   {
22696     try {
22697       delete arg1;
22698     } catch (std::out_of_range& e) {
22699       {
22700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22701       };
22702     } catch (std::exception& e) {
22703       {
22704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22705       };
22706     } catch (Dali::DaliException e) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22709       };
22710     } catch (...) {
22711       {
22712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22713       };
22714     }
22715   }
22716
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22721   void * jresult ;
22722   Dali::TypeRegistration *arg1 = 0 ;
22723   std::string *arg2 = 0 ;
22724   Dali::Property::Index arg3 ;
22725   Dali::Property::Type arg4 ;
22726   Dali::ChildPropertyRegistration *result = 0 ;
22727
22728   arg1 = (Dali::TypeRegistration *)jarg1;
22729   if (!arg1) {
22730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22731     return 0;
22732   }
22733   if (!jarg2) {
22734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22735     return 0;
22736   }
22737   std::string arg2_str(jarg2);
22738   arg2 = &arg2_str;
22739   arg3 = (Dali::Property::Index)jarg3;
22740   arg4 = (Dali::Property::Type)jarg4;
22741   {
22742     try {
22743       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (Dali::DaliException e) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22755       };
22756     } catch (...) {
22757       {
22758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22759       };
22760     }
22761   }
22762
22763   jresult = (void *)result;
22764
22765   //argout typemap for const std::string&
22766
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22772   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22773
22774   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22775   {
22776     try {
22777       delete arg1;
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22785       };
22786     } catch (Dali::DaliException e) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22789       };
22790     } catch (...) {
22791       {
22792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22793       };
22794     }
22795   }
22796
22797 }
22798
22799
22800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22801   unsigned int jresult ;
22802   std::string *arg1 = 0 ;
22803   std::type_info *arg2 = 0 ;
22804   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22805   bool result;
22806
22807   if (!jarg1) {
22808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22809     return 0;
22810   }
22811   std::string arg1_str(jarg1);
22812   arg1 = &arg1_str;
22813   arg2 = (std::type_info *)jarg2;
22814   if (!arg2) {
22815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22816     return 0;
22817   }
22818   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22819   {
22820     try {
22821       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22829       };
22830     } catch (Dali::DaliException e) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22833       };
22834     } catch (...) {
22835       {
22836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22837       };
22838     }
22839   }
22840
22841   jresult = result;
22842
22843   //argout typemap for const std::string&
22844
22845   return jresult;
22846 }
22847
22848
22849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22850   unsigned int jresult ;
22851   std::string *arg1 = 0 ;
22852   std::string *arg2 = 0 ;
22853   Dali::Property::Index arg3 ;
22854   Dali::Property::Type arg4 ;
22855   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22856   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22857   bool result;
22858
22859   if (!jarg1) {
22860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22861     return 0;
22862   }
22863   std::string arg1_str(jarg1);
22864   arg1 = &arg1_str;
22865   if (!jarg2) {
22866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22867     return 0;
22868   }
22869   std::string arg2_str(jarg2);
22870   arg2 = &arg2_str;
22871   arg3 = (Dali::Property::Index)jarg3;
22872   arg4 = (Dali::Property::Type)jarg4;
22873   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22874   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22875   {
22876     try {
22877       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (Dali::DaliException e) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22889       };
22890     } catch (...) {
22891       {
22892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22893       };
22894     }
22895   }
22896
22897   jresult = result;
22898
22899   //argout typemap for const std::string&
22900
22901
22902   //argout typemap for const std::string&
22903
22904   return jresult;
22905 }
22906
22907
22908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22909   float jresult ;
22910   float result;
22911
22912   result = (float)(float)Dali::ParentOrigin::TOP;
22913   jresult = result;
22914   return jresult;
22915 }
22916
22917
22918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22919   float jresult ;
22920   float result;
22921
22922   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22923   jresult = result;
22924   return jresult;
22925 }
22926
22927
22928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22929   float jresult ;
22930   float result;
22931
22932   result = (float)(float)Dali::ParentOrigin::LEFT;
22933   jresult = result;
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::RIGHT;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22959   void * jresult ;
22960   Dali::Vector3 *result = 0 ;
22961
22962   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22963   jresult = (void *)result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22969   void * jresult ;
22970   Dali::Vector3 *result = 0 ;
22971
22972   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22973   jresult = (void *)result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22979   void * jresult ;
22980   Dali::Vector3 *result = 0 ;
22981
22982   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22983   jresult = (void *)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23049   float jresult ;
23050   float result;
23051
23052   result = (float)(float)Dali::AnchorPoint::TOP;
23053   jresult = result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23059   float jresult ;
23060   float result;
23061
23062   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23063   jresult = result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23069   float jresult ;
23070   float result;
23071
23072   result = (float)(float)Dali::AnchorPoint::LEFT;
23073   jresult = result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::RIGHT;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23099   void * jresult ;
23100   Dali::Vector3 *result = 0 ;
23101
23102   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23103   jresult = (void *)result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23109   void * jresult ;
23110   Dali::Vector3 *result = 0 ;
23111
23112   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23113   jresult = (void *)result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23119   void * jresult ;
23120   Dali::Vector3 *result = 0 ;
23121
23122   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23123   jresult = (void *)result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23189   void * jresult ;
23190   Dali::Vector4 *result = 0 ;
23191
23192   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23199   void * jresult ;
23200   Dali::Vector4 *result = 0 ;
23201
23202   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23209   void * jresult ;
23210   Dali::Vector4 *result = 0 ;
23211
23212   result = (Dali::Vector4 *)&Dali::Color::RED;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23279   float jresult ;
23280   float result;
23281
23282   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23283   jresult = result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23289   float jresult ;
23290   float result;
23291
23292   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23293   jresult = result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23299   float jresult ;
23300   float result;
23301
23302   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23303   jresult = result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::PI;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::PI_2;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::PI_4;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI_OVER_180;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23389   int jresult ;
23390   Dali::ResizePolicy::Type result;
23391
23392   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23399   unsigned long jresult ;
23400   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23401   Dali::VectorBase::SizeType result;
23402
23403   arg1 = (Dali::VectorBase *)jarg1;
23404   {
23405     try {
23406       result = ((Dali::VectorBase const *)arg1)->Count();
23407     } catch (std::out_of_range& e) {
23408       {
23409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23410       };
23411     } catch (std::exception& e) {
23412       {
23413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23414       };
23415     } catch (Dali::DaliException e) {
23416       {
23417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23418       };
23419     } catch (...) {
23420       {
23421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23422       };
23423     }
23424   }
23425
23426   jresult = (unsigned long)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23432   unsigned long jresult ;
23433   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23434   Dali::VectorBase::SizeType result;
23435
23436   arg1 = (Dali::VectorBase *)jarg1;
23437   {
23438     try {
23439       result = ((Dali::VectorBase const *)arg1)->Size();
23440     } catch (std::out_of_range& e) {
23441       {
23442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23443       };
23444     } catch (std::exception& e) {
23445       {
23446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (Dali::DaliException e) {
23449       {
23450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23451       };
23452     } catch (...) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23455       };
23456     }
23457   }
23458
23459   jresult = (unsigned long)result;
23460   return jresult;
23461 }
23462
23463
23464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23465   unsigned int jresult ;
23466   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23467   bool result;
23468
23469   arg1 = (Dali::VectorBase *)jarg1;
23470   {
23471     try {
23472       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23473     } catch (std::out_of_range& e) {
23474       {
23475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23476       };
23477     } catch (std::exception& e) {
23478       {
23479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (Dali::DaliException e) {
23482       {
23483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23484       };
23485     } catch (...) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23488       };
23489     }
23490   }
23491
23492   jresult = result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23498   unsigned long jresult ;
23499   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23500   Dali::VectorBase::SizeType result;
23501
23502   arg1 = (Dali::VectorBase *)jarg1;
23503   {
23504     try {
23505       result = ((Dali::VectorBase const *)arg1)->Capacity();
23506     } catch (std::out_of_range& e) {
23507       {
23508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23509       };
23510     } catch (std::exception& e) {
23511       {
23512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (Dali::DaliException e) {
23515       {
23516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23517       };
23518     } catch (...) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23521       };
23522     }
23523   }
23524
23525   jresult = (unsigned long)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23531   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23532
23533   arg1 = (Dali::VectorBase *)jarg1;
23534   {
23535     try {
23536       (arg1)->Release();
23537     } catch (std::out_of_range& e) {
23538       {
23539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23540       };
23541     } catch (std::exception& e) {
23542       {
23543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23544       };
23545     } catch (Dali::DaliException e) {
23546       {
23547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23548       };
23549     } catch (...) {
23550       {
23551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23552       };
23553     }
23554   }
23555
23556 }
23557
23558
23559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23560   void * jresult ;
23561   Dali::Image *result = 0 ;
23562
23563   {
23564     try {
23565       result = (Dali::Image *)new Dali::Image();
23566     } catch (std::out_of_range& e) {
23567       {
23568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23569       };
23570     } catch (std::exception& e) {
23571       {
23572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23573       };
23574     } catch (Dali::DaliException e) {
23575       {
23576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23581       };
23582     }
23583   }
23584
23585   jresult = (void *)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23591   Dali::Image *arg1 = (Dali::Image *) 0 ;
23592
23593   arg1 = (Dali::Image *)jarg1;
23594   {
23595     try {
23596       delete arg1;
23597     } catch (std::out_of_range& e) {
23598       {
23599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23600       };
23601     } catch (std::exception& e) {
23602       {
23603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23604       };
23605     } catch (Dali::DaliException e) {
23606       {
23607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23608       };
23609     } catch (...) {
23610       {
23611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23612       };
23613     }
23614   }
23615
23616 }
23617
23618
23619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23620   void * jresult ;
23621   Dali::Image *arg1 = 0 ;
23622   Dali::Image *result = 0 ;
23623
23624   arg1 = (Dali::Image *)jarg1;
23625   if (!arg1) {
23626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23627     return 0;
23628   }
23629   {
23630     try {
23631       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (Dali::DaliException e) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23643       };
23644     } catch (...) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23647       };
23648     }
23649   }
23650
23651   jresult = (void *)result;
23652   return jresult;
23653 }
23654
23655
23656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23657   void * jresult ;
23658   Dali::Image *arg1 = (Dali::Image *) 0 ;
23659   Dali::Image *arg2 = 0 ;
23660   Dali::Image *result = 0 ;
23661
23662   arg1 = (Dali::Image *)jarg1;
23663   arg2 = (Dali::Image *)jarg2;
23664   if (!arg2) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (Dali::DaliException e) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23682       };
23683     } catch (...) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23686       };
23687     }
23688   }
23689
23690   jresult = (void *)result;
23691   return jresult;
23692 }
23693
23694
23695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23696   void * jresult ;
23697   Dali::BaseHandle arg1 ;
23698   Dali::BaseHandle *argp1 ;
23699   Dali::Image result;
23700
23701   argp1 = (Dali::BaseHandle *)jarg1;
23702   if (!argp1) {
23703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23704     return 0;
23705   }
23706   arg1 = *argp1;
23707   {
23708     try {
23709       result = Dali::Image::DownCast(arg1);
23710     } catch (std::out_of_range& e) {
23711       {
23712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23713       };
23714     } catch (std::exception& e) {
23715       {
23716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23717       };
23718     } catch (Dali::DaliException e) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23725       };
23726     }
23727   }
23728
23729   jresult = new Dali::Image((const Dali::Image &)result);
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23735   unsigned int jresult ;
23736   Dali::Image *arg1 = (Dali::Image *) 0 ;
23737   unsigned int result;
23738
23739   arg1 = (Dali::Image *)jarg1;
23740   {
23741     try {
23742       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23743     } catch (std::out_of_range& e) {
23744       {
23745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (std::exception& e) {
23748       {
23749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (Dali::DaliException e) {
23752       {
23753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761
23762   jresult = result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23768   unsigned int jresult ;
23769   Dali::Image *arg1 = (Dali::Image *) 0 ;
23770   unsigned int result;
23771
23772   arg1 = (Dali::Image *)jarg1;
23773   {
23774     try {
23775       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23776     } catch (std::out_of_range& e) {
23777       {
23778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23779       };
23780     } catch (std::exception& e) {
23781       {
23782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (Dali::DaliException e) {
23785       {
23786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23787       };
23788     } catch (...) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23791       };
23792     }
23793   }
23794
23795   jresult = result;
23796   return jresult;
23797 }
23798
23799
23800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23801   void * jresult ;
23802   Dali::Image *arg1 = (Dali::Image *) 0 ;
23803   Dali::Image::ImageSignalType *result = 0 ;
23804
23805   arg1 = (Dali::Image *)jarg1;
23806   {
23807     try {
23808       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23809     } catch (std::out_of_range& e) {
23810       {
23811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (std::exception& e) {
23814       {
23815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (Dali::DaliException e) {
23818       {
23819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23820       };
23821     } catch (...) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23824       };
23825     }
23826   }
23827
23828   jresult = (void *)result;
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23834   int jresult ;
23835   Dali::Pixel::Format result;
23836
23837   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23838   jresult = (int)result;
23839   return jresult;
23840 }
23841
23842
23843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23844   int jresult ;
23845   Dali::Pixel::Format result;
23846
23847   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23848   jresult = (int)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23854   unsigned int jresult ;
23855   Dali::Pixel::Format arg1 ;
23856   bool result;
23857
23858   arg1 = (Dali::Pixel::Format)jarg1;
23859   {
23860     try {
23861       result = (bool)Dali::Pixel::HasAlpha(arg1);
23862     } catch (std::out_of_range& e) {
23863       {
23864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23865       };
23866     } catch (std::exception& e) {
23867       {
23868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (Dali::DaliException e) {
23871       {
23872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23873       };
23874     } catch (...) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23877       };
23878     }
23879   }
23880
23881   jresult = result;
23882   return jresult;
23883 }
23884
23885
23886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23887   unsigned int jresult ;
23888   Dali::Pixel::Format arg1 ;
23889   unsigned int result;
23890
23891   arg1 = (Dali::Pixel::Format)jarg1;
23892   {
23893     try {
23894       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23895     } catch (std::out_of_range& e) {
23896       {
23897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (std::exception& e) {
23900       {
23901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (Dali::DaliException e) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23906       };
23907     } catch (...) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23910       };
23911     }
23912   }
23913
23914   jresult = result;
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23920   Dali::Pixel::Format arg1 ;
23921   int *arg2 = 0 ;
23922   int *arg3 = 0 ;
23923
23924   arg1 = (Dali::Pixel::Format)jarg1;
23925   arg2 = (int *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23928     return ;
23929   }
23930   arg3 = (int *)jarg3;
23931   if (!arg3) {
23932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23933     return ;
23934   }
23935   {
23936     try {
23937       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23945       };
23946     } catch (Dali::DaliException e) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23949       };
23950     } catch (...) {
23951       {
23952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23953       };
23954     }
23955   }
23956
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23961   void * jresult ;
23962   unsigned char *arg1 = (unsigned char *) 0 ;
23963   unsigned int arg2 ;
23964   unsigned int arg3 ;
23965   unsigned int arg4 ;
23966   Dali::Pixel::Format arg5 ;
23967   Dali::PixelData::ReleaseFunction arg6 ;
23968   Dali::PixelData result;
23969
23970   arg1 = jarg1;
23971   arg2 = (unsigned int)jarg2;
23972   arg3 = (unsigned int)jarg3;
23973   arg4 = (unsigned int)jarg4;
23974   arg5 = (Dali::Pixel::Format)jarg5;
23975   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23976   {
23977     try {
23978       auto pixelBuffer = new unsigned char[jarg2];
23979       memcpy( pixelBuffer, arg1, arg2);
23980       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (Dali::DaliException e) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999
24000   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24001
24002
24003   return jresult;
24004 }
24005
24006
24007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24008   void * jresult ;
24009   Dali::PixelData *result = 0 ;
24010
24011   {
24012     try {
24013       result = (Dali::PixelData *)new Dali::PixelData();
24014     } catch (std::out_of_range& e) {
24015       {
24016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (std::exception& e) {
24019       {
24020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24021       };
24022     } catch (Dali::DaliException e) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24025       };
24026     } catch (...) {
24027       {
24028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24029       };
24030     }
24031   }
24032
24033   jresult = (void *)result;
24034   return jresult;
24035 }
24036
24037
24038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24039   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24040
24041   arg1 = (Dali::PixelData *)jarg1;
24042   {
24043     try {
24044       delete arg1;
24045     } catch (std::out_of_range& e) {
24046       {
24047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24048       };
24049     } catch (std::exception& e) {
24050       {
24051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24052       };
24053     } catch (Dali::DaliException e) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24056       };
24057     } catch (...) {
24058       {
24059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24060       };
24061     }
24062   }
24063
24064 }
24065
24066
24067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24068   void * jresult ;
24069   Dali::PixelData *arg1 = 0 ;
24070   Dali::PixelData *result = 0 ;
24071
24072   arg1 = (Dali::PixelData *)jarg1;
24073   if (!arg1) {
24074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24075     return 0;
24076   }
24077   {
24078     try {
24079       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24080     } catch (std::out_of_range& e) {
24081       {
24082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (std::exception& e) {
24085       {
24086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (Dali::DaliException e) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24091       };
24092     } catch (...) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24095       };
24096     }
24097   }
24098
24099   jresult = (void *)result;
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24105   void * jresult ;
24106   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24107   Dali::PixelData *arg2 = 0 ;
24108   Dali::PixelData *result = 0 ;
24109
24110   arg1 = (Dali::PixelData *)jarg1;
24111   arg2 = (Dali::PixelData *)jarg2;
24112   if (!arg2) {
24113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24114     return 0;
24115   }
24116   {
24117     try {
24118       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24119     } catch (std::out_of_range& e) {
24120       {
24121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24122       };
24123     } catch (std::exception& e) {
24124       {
24125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (Dali::DaliException e) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137
24138   jresult = (void *)result;
24139   return jresult;
24140 }
24141
24142
24143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24144   unsigned int jresult ;
24145   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24146   unsigned int result;
24147
24148   arg1 = (Dali::PixelData *)jarg1;
24149   {
24150     try {
24151       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (Dali::DaliException e) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170
24171   jresult = result;
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24177   unsigned int jresult ;
24178   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24179   unsigned int result;
24180
24181   arg1 = (Dali::PixelData *)jarg1;
24182   {
24183     try {
24184       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24185     } catch (std::out_of_range& e) {
24186       {
24187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (std::exception& e) {
24190       {
24191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (Dali::DaliException e) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24196       };
24197     } catch (...) {
24198       {
24199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24200       };
24201     }
24202   }
24203
24204   jresult = result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24210   int jresult ;
24211   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24212   Dali::Pixel::Format result;
24213
24214   arg1 = (Dali::PixelData *)jarg1;
24215   {
24216     try {
24217       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24218     } catch (std::out_of_range& e) {
24219       {
24220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (std::exception& e) {
24223       {
24224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24225       };
24226     } catch (Dali::DaliException e) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24233       };
24234     }
24235   }
24236
24237   jresult = (int)result;
24238   return jresult;
24239 }
24240
24241
24242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24243   unsigned int jresult ;
24244   unsigned int result;
24245
24246   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24247   jresult = result;
24248   return jresult;
24249 }
24250
24251
24252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24253   unsigned int jresult ;
24254   unsigned int result;
24255
24256   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24257   jresult = result;
24258   return jresult;
24259 }
24260
24261
24262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24263   unsigned int jresult ;
24264   unsigned int result;
24265
24266   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24267   jresult = result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24273   unsigned int jresult ;
24274   unsigned int result;
24275
24276   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24277   jresult = result;
24278   return jresult;
24279 }
24280
24281
24282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24283   unsigned int jresult ;
24284   unsigned int result;
24285
24286   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24287   jresult = result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24293   unsigned int jresult ;
24294   unsigned int result;
24295
24296   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24297   jresult = result;
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24303   void * jresult ;
24304   Dali::TextureType::Type arg1 ;
24305   Dali::Pixel::Format arg2 ;
24306   unsigned int arg3 ;
24307   unsigned int arg4 ;
24308   Dali::Texture result;
24309
24310   arg1 = (Dali::TextureType::Type)jarg1;
24311   arg2 = (Dali::Pixel::Format)jarg2;
24312   arg3 = (unsigned int)jarg3;
24313   arg4 = (unsigned int)jarg4;
24314   {
24315     try {
24316       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24317     } catch (std::out_of_range& e) {
24318       {
24319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (std::exception& e) {
24322       {
24323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24324       };
24325     } catch (Dali::DaliException e) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24328       };
24329     } catch (...) {
24330       {
24331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24332       };
24333     }
24334   }
24335
24336   jresult = new Dali::Texture((const Dali::Texture &)result);
24337   return jresult;
24338 }
24339
24340
24341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24342   void * jresult ;
24343   NativeImageInterface *arg1 = 0 ;
24344   Dali::Texture result;
24345
24346   arg1 = (NativeImageInterface *)jarg1;
24347   if (!arg1) {
24348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24349     return 0;
24350   }
24351   {
24352     try {
24353       result = Dali::Texture::New(*arg1);
24354     } catch (std::out_of_range& e) {
24355       {
24356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (std::exception& e) {
24359       {
24360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24361       };
24362     } catch (Dali::DaliException e) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24365       };
24366     } catch (...) {
24367       {
24368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24369       };
24370     }
24371   }
24372
24373   jresult = new Dali::Texture((const Dali::Texture &)result);
24374   return jresult;
24375 }
24376
24377
24378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24379   void * jresult ;
24380   Dali::Texture *result = 0 ;
24381
24382   {
24383     try {
24384       result = (Dali::Texture *)new Dali::Texture();
24385     } catch (std::out_of_range& e) {
24386       {
24387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (std::exception& e) {
24390       {
24391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (Dali::DaliException e) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24396       };
24397     } catch (...) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24400       };
24401     }
24402   }
24403
24404   jresult = (void *)result;
24405   return jresult;
24406 }
24407
24408
24409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24410   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24411
24412   arg1 = (Dali::Texture *)jarg1;
24413   {
24414     try {
24415       delete arg1;
24416     } catch (std::out_of_range& e) {
24417       {
24418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24419       };
24420     } catch (std::exception& e) {
24421       {
24422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24423       };
24424     } catch (Dali::DaliException e) {
24425       {
24426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24427       };
24428     } catch (...) {
24429       {
24430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24431       };
24432     }
24433   }
24434
24435 }
24436
24437
24438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24439   void * jresult ;
24440   Dali::Texture *arg1 = 0 ;
24441   Dali::Texture *result = 0 ;
24442
24443   arg1 = (Dali::Texture *)jarg1;
24444   if (!arg1) {
24445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24446     return 0;
24447   }
24448   {
24449     try {
24450       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24458       };
24459     } catch (Dali::DaliException e) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24462       };
24463     } catch (...) {
24464       {
24465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24466       };
24467     }
24468   }
24469
24470   jresult = (void *)result;
24471   return jresult;
24472 }
24473
24474
24475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24476   void * jresult ;
24477   Dali::BaseHandle arg1 ;
24478   Dali::BaseHandle *argp1 ;
24479   Dali::Texture result;
24480
24481   argp1 = (Dali::BaseHandle *)jarg1;
24482   if (!argp1) {
24483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24484     return 0;
24485   }
24486   arg1 = *argp1;
24487   {
24488     try {
24489       result = Dali::Texture::DownCast(arg1);
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (Dali::DaliException e) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24505       };
24506     }
24507   }
24508
24509   jresult = new Dali::Texture((const Dali::Texture &)result);
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24515   void * jresult ;
24516   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24517   Dali::Texture *arg2 = 0 ;
24518   Dali::Texture *result = 0 ;
24519
24520   arg1 = (Dali::Texture *)jarg1;
24521   arg2 = (Dali::Texture *)jarg2;
24522   if (!arg2) {
24523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24524     return 0;
24525   }
24526   {
24527     try {
24528       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = (void *)result;
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24554   unsigned int jresult ;
24555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24556   Dali::PixelData arg2 ;
24557   Dali::PixelData *argp2 ;
24558   bool result;
24559
24560   arg1 = (Dali::Texture *)jarg1;
24561   argp2 = (Dali::PixelData *)jarg2;
24562   if (!argp2) {
24563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24564     return 0;
24565   }
24566   arg2 = *argp2;
24567   {
24568     try {
24569       result = (bool)(arg1)->Upload(arg2);
24570     } catch (std::out_of_range& e) {
24571       {
24572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24573       };
24574     } catch (std::exception& e) {
24575       {
24576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24577       };
24578     } catch (Dali::DaliException e) {
24579       {
24580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24581       };
24582     } catch (...) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24585       };
24586     }
24587   }
24588
24589   jresult = result;
24590   return jresult;
24591 }
24592
24593
24594 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) {
24595   unsigned int jresult ;
24596   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24597   Dali::PixelData arg2 ;
24598   unsigned int arg3 ;
24599   unsigned int arg4 ;
24600   unsigned int arg5 ;
24601   unsigned int arg6 ;
24602   unsigned int arg7 ;
24603   unsigned int arg8 ;
24604   Dali::PixelData *argp2 ;
24605   bool result;
24606
24607   arg1 = (Dali::Texture *)jarg1;
24608   argp2 = (Dali::PixelData *)jarg2;
24609   if (!argp2) {
24610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24611     return 0;
24612   }
24613   arg2 = *argp2;
24614   arg3 = (unsigned int)jarg3;
24615   arg4 = (unsigned int)jarg4;
24616   arg5 = (unsigned int)jarg5;
24617   arg6 = (unsigned int)jarg6;
24618   arg7 = (unsigned int)jarg7;
24619   arg8 = (unsigned int)jarg8;
24620   {
24621     try {
24622       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24623     } catch (std::out_of_range& e) {
24624       {
24625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24626       };
24627     } catch (std::exception& e) {
24628       {
24629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24630       };
24631     } catch (Dali::DaliException e) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24634       };
24635     } catch (...) {
24636       {
24637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24638       };
24639     }
24640   }
24641
24642   jresult = result;
24643   return jresult;
24644 }
24645
24646
24647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24648   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24649
24650   arg1 = (Dali::Texture *)jarg1;
24651   {
24652     try {
24653       (arg1)->GenerateMipmaps();
24654     } catch (std::out_of_range& e) {
24655       {
24656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24657       };
24658     } catch (std::exception& e) {
24659       {
24660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24661       };
24662     } catch (Dali::DaliException e) {
24663       {
24664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24665       };
24666     } catch (...) {
24667       {
24668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24669       };
24670     }
24671   }
24672
24673 }
24674
24675
24676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24677   unsigned int jresult ;
24678   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24679   unsigned int result;
24680
24681   arg1 = (Dali::Texture *)jarg1;
24682   {
24683     try {
24684       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24685     } catch (std::out_of_range& e) {
24686       {
24687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (std::exception& e) {
24690       {
24691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24692       };
24693     } catch (Dali::DaliException e) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24696       };
24697     } catch (...) {
24698       {
24699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24700       };
24701     }
24702   }
24703
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24710   unsigned int jresult ;
24711   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24712   unsigned int result;
24713
24714   arg1 = (Dali::Texture *)jarg1;
24715   {
24716     try {
24717       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24718     } catch (std::out_of_range& e) {
24719       {
24720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24721       };
24722     } catch (std::exception& e) {
24723       {
24724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24725       };
24726     } catch (Dali::DaliException e) {
24727       {
24728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24729       };
24730     } catch (...) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24733       };
24734     }
24735   }
24736
24737   jresult = result;
24738   return jresult;
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24743   void * jresult ;
24744   Dali::Sampler result;
24745
24746   {
24747     try {
24748       result = Dali::Sampler::New();
24749     } catch (std::out_of_range& e) {
24750       {
24751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (std::exception& e) {
24754       {
24755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24756       };
24757     } catch (Dali::DaliException e) {
24758       {
24759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24760       };
24761     } catch (...) {
24762       {
24763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24764       };
24765     }
24766   }
24767
24768   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24769   return jresult;
24770 }
24771
24772
24773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24774   void * jresult ;
24775   Dali::Sampler *result = 0 ;
24776
24777   {
24778     try {
24779       result = (Dali::Sampler *)new Dali::Sampler();
24780     } catch (std::out_of_range& e) {
24781       {
24782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (std::exception& e) {
24785       {
24786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24787       };
24788     } catch (Dali::DaliException e) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24791       };
24792     } catch (...) {
24793       {
24794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24795       };
24796     }
24797   }
24798
24799   jresult = (void *)result;
24800   return jresult;
24801 }
24802
24803
24804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24805   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24806
24807   arg1 = (Dali::Sampler *)jarg1;
24808   {
24809     try {
24810       delete arg1;
24811     } catch (std::out_of_range& e) {
24812       {
24813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (std::exception& e) {
24816       {
24817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24818       };
24819     } catch (Dali::DaliException e) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24822       };
24823     } catch (...) {
24824       {
24825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24826       };
24827     }
24828   }
24829
24830 }
24831
24832
24833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24834   void * jresult ;
24835   Dali::Sampler *arg1 = 0 ;
24836   Dali::Sampler *result = 0 ;
24837
24838   arg1 = (Dali::Sampler *)jarg1;
24839   if (!arg1) {
24840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24841     return 0;
24842   }
24843   {
24844     try {
24845       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24846     } catch (std::out_of_range& e) {
24847       {
24848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24849       };
24850     } catch (std::exception& e) {
24851       {
24852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (Dali::DaliException e) {
24855       {
24856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24857       };
24858     } catch (...) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24861       };
24862     }
24863   }
24864
24865   jresult = (void *)result;
24866   return jresult;
24867 }
24868
24869
24870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24871   void * jresult ;
24872   Dali::BaseHandle arg1 ;
24873   Dali::BaseHandle *argp1 ;
24874   Dali::Sampler result;
24875
24876   argp1 = (Dali::BaseHandle *)jarg1;
24877   if (!argp1) {
24878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24879     return 0;
24880   }
24881   arg1 = *argp1;
24882   {
24883     try {
24884       result = Dali::Sampler::DownCast(arg1);
24885     } catch (std::out_of_range& e) {
24886       {
24887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (std::exception& e) {
24890       {
24891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24892       };
24893     } catch (Dali::DaliException e) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24900       };
24901     }
24902   }
24903
24904   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24905   return jresult;
24906 }
24907
24908
24909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24910   void * jresult ;
24911   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24912   Dali::Sampler *arg2 = 0 ;
24913   Dali::Sampler *result = 0 ;
24914
24915   arg1 = (Dali::Sampler *)jarg1;
24916   arg2 = (Dali::Sampler *)jarg2;
24917   if (!arg2) {
24918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24919     return 0;
24920   }
24921   {
24922     try {
24923       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24924     } catch (std::out_of_range& e) {
24925       {
24926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (std::exception& e) {
24929       {
24930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24931       };
24932     } catch (Dali::DaliException e) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24935       };
24936     } catch (...) {
24937       {
24938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24939       };
24940     }
24941   }
24942
24943   jresult = (void *)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24949   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24950   Dali::FilterMode::Type arg2 ;
24951   Dali::FilterMode::Type arg3 ;
24952
24953   arg1 = (Dali::Sampler *)jarg1;
24954   arg2 = (Dali::FilterMode::Type)jarg2;
24955   arg3 = (Dali::FilterMode::Type)jarg3;
24956   {
24957     try {
24958       (arg1)->SetFilterMode(arg2,arg3);
24959     } catch (std::out_of_range& e) {
24960       {
24961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (std::exception& e) {
24964       {
24965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24966       };
24967     } catch (Dali::DaliException e) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24970       };
24971     } catch (...) {
24972       {
24973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24974       };
24975     }
24976   }
24977
24978 }
24979
24980
24981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24982   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24983   Dali::WrapMode::Type arg2 ;
24984   Dali::WrapMode::Type arg3 ;
24985
24986   arg1 = (Dali::Sampler *)jarg1;
24987   arg2 = (Dali::WrapMode::Type)jarg2;
24988   arg3 = (Dali::WrapMode::Type)jarg3;
24989   {
24990     try {
24991       (arg1)->SetWrapMode(arg2,arg3);
24992     } catch (std::out_of_range& e) {
24993       {
24994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (std::exception& e) {
24997       {
24998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24999       };
25000     } catch (Dali::DaliException e) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25003       };
25004     } catch (...) {
25005       {
25006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25007       };
25008     }
25009   }
25010
25011 }
25012
25013
25014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25015   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25016   Dali::WrapMode::Type arg2 ;
25017   Dali::WrapMode::Type arg3 ;
25018   Dali::WrapMode::Type arg4 ;
25019
25020   arg1 = (Dali::Sampler *)jarg1;
25021   arg2 = (Dali::WrapMode::Type)jarg2;
25022   arg3 = (Dali::WrapMode::Type)jarg3;
25023   arg4 = (Dali::WrapMode::Type)jarg4;
25024   {
25025     try {
25026       (arg1)->SetWrapMode(arg2,arg3,arg4);
25027     } catch (std::out_of_range& e) {
25028       {
25029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25030       };
25031     } catch (std::exception& e) {
25032       {
25033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25034       };
25035     } catch (Dali::DaliException e) {
25036       {
25037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25038       };
25039     } catch (...) {
25040       {
25041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25042       };
25043     }
25044   }
25045
25046 }
25047
25048
25049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25050   void * jresult ;
25051   Dali::TextureSet result;
25052
25053   {
25054     try {
25055       result = Dali::TextureSet::New();
25056     } catch (std::out_of_range& e) {
25057       {
25058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (std::exception& e) {
25061       {
25062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25063       };
25064     } catch (Dali::DaliException e) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25067       };
25068     } catch (...) {
25069       {
25070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25071       };
25072     }
25073   }
25074
25075   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25076   return jresult;
25077 }
25078
25079
25080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25081   void * jresult ;
25082   Dali::TextureSet *result = 0 ;
25083
25084   {
25085     try {
25086       result = (Dali::TextureSet *)new Dali::TextureSet();
25087     } catch (std::out_of_range& e) {
25088       {
25089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (std::exception& e) {
25092       {
25093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25094       };
25095     } catch (Dali::DaliException e) {
25096       {
25097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25098       };
25099     } catch (...) {
25100       {
25101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25102       };
25103     }
25104   }
25105
25106   jresult = (void *)result;
25107   return jresult;
25108 }
25109
25110
25111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25112   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25113
25114   arg1 = (Dali::TextureSet *)jarg1;
25115   {
25116     try {
25117       delete arg1;
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25125       };
25126     } catch (Dali::DaliException e) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25129       };
25130     } catch (...) {
25131       {
25132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25133       };
25134     }
25135   }
25136
25137 }
25138
25139
25140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25141   void * jresult ;
25142   Dali::TextureSet *arg1 = 0 ;
25143   Dali::TextureSet *result = 0 ;
25144
25145   arg1 = (Dali::TextureSet *)jarg1;
25146   if (!arg1) {
25147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25148     return 0;
25149   }
25150   {
25151     try {
25152       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25153     } catch (std::out_of_range& e) {
25154       {
25155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25156       };
25157     } catch (std::exception& e) {
25158       {
25159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (Dali::DaliException e) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25164       };
25165     } catch (...) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25168       };
25169     }
25170   }
25171
25172   jresult = (void *)result;
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25178   void * jresult ;
25179   Dali::BaseHandle arg1 ;
25180   Dali::BaseHandle *argp1 ;
25181   Dali::TextureSet result;
25182
25183   argp1 = (Dali::BaseHandle *)jarg1;
25184   if (!argp1) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25186     return 0;
25187   }
25188   arg1 = *argp1;
25189   {
25190     try {
25191       result = Dali::TextureSet::DownCast(arg1);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (Dali::DaliException e) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25203       };
25204     } catch (...) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25207       };
25208     }
25209   }
25210
25211   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25212   return jresult;
25213 }
25214
25215
25216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25217   void * jresult ;
25218   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25219   Dali::TextureSet *arg2 = 0 ;
25220   Dali::TextureSet *result = 0 ;
25221
25222   arg1 = (Dali::TextureSet *)jarg1;
25223   arg2 = (Dali::TextureSet *)jarg2;
25224   if (!arg2) {
25225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25226     return 0;
25227   }
25228   {
25229     try {
25230       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25231     } catch (std::out_of_range& e) {
25232       {
25233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (std::exception& e) {
25236       {
25237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25238       };
25239     } catch (Dali::DaliException e) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25242       };
25243     } catch (...) {
25244       {
25245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25246       };
25247     }
25248   }
25249
25250   jresult = (void *)result;
25251   return jresult;
25252 }
25253
25254
25255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25256   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25257   size_t arg2 ;
25258   Dali::Texture arg3 ;
25259   Dali::Texture *argp3 ;
25260
25261   arg1 = (Dali::TextureSet *)jarg1;
25262   arg2 = (size_t)jarg2;
25263   argp3 = (Dali::Texture *)jarg3;
25264   if (!argp3) {
25265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25266     return ;
25267   }
25268   arg3 = *argp3;
25269   {
25270     try {
25271       (arg1)->SetTexture(arg2,arg3);
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25279       };
25280     } catch (Dali::DaliException e) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25283       };
25284     } catch (...) {
25285       {
25286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25287       };
25288     }
25289   }
25290
25291 }
25292
25293
25294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25295   void * jresult ;
25296   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25297   size_t arg2 ;
25298   Dali::Texture result;
25299
25300   arg1 = (Dali::TextureSet *)jarg1;
25301   arg2 = (size_t)jarg2;
25302   {
25303     try {
25304       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25305     } catch (std::out_of_range& e) {
25306       {
25307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (std::exception& e) {
25310       {
25311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25312       };
25313     } catch (Dali::DaliException e) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25316       };
25317     } catch (...) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25320       };
25321     }
25322   }
25323
25324   jresult = new Dali::Texture((const Dali::Texture &)result);
25325   return jresult;
25326 }
25327
25328
25329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25330   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25331   size_t arg2 ;
25332   Dali::Sampler arg3 ;
25333   Dali::Sampler *argp3 ;
25334
25335   arg1 = (Dali::TextureSet *)jarg1;
25336   arg2 = (size_t)jarg2;
25337   argp3 = (Dali::Sampler *)jarg3;
25338   if (!argp3) {
25339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25340     return ;
25341   }
25342   arg3 = *argp3;
25343   {
25344     try {
25345       (arg1)->SetSampler(arg2,arg3);
25346     } catch (std::out_of_range& e) {
25347       {
25348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (std::exception& e) {
25351       {
25352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25353       };
25354     } catch (Dali::DaliException e) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25357       };
25358     } catch (...) {
25359       {
25360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25361       };
25362     }
25363   }
25364
25365 }
25366
25367
25368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25369   void * jresult ;
25370   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25371   size_t arg2 ;
25372   Dali::Sampler result;
25373
25374   arg1 = (Dali::TextureSet *)jarg1;
25375   arg2 = (size_t)jarg2;
25376   {
25377     try {
25378       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25379     } catch (std::out_of_range& e) {
25380       {
25381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (std::exception& e) {
25384       {
25385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25386       };
25387     } catch (Dali::DaliException e) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25390       };
25391     } catch (...) {
25392       {
25393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25394       };
25395     }
25396   }
25397
25398   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25399   return jresult;
25400 }
25401
25402
25403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25404   unsigned long jresult ;
25405   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25406   size_t result;
25407
25408   arg1 = (Dali::TextureSet *)jarg1;
25409   {
25410     try {
25411       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25412     } catch (std::out_of_range& e) {
25413       {
25414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (std::exception& e) {
25417       {
25418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25419       };
25420     } catch (Dali::DaliException e) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25423       };
25424     } catch (...) {
25425       {
25426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25427       };
25428     }
25429   }
25430
25431   jresult = (unsigned long)result;
25432   return jresult;
25433 }
25434
25435
25436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25437   void * jresult ;
25438   Dali::Property::Map *arg1 = 0 ;
25439   Dali::PropertyBuffer result;
25440
25441   arg1 = (Dali::Property::Map *)jarg1;
25442   if (!arg1) {
25443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25444     return 0;
25445   }
25446   {
25447     try {
25448       result = Dali::PropertyBuffer::New(*arg1);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (Dali::DaliException e) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467
25468   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25469   return jresult;
25470 }
25471
25472
25473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25474   void * jresult ;
25475   Dali::PropertyBuffer *result = 0 ;
25476
25477   {
25478     try {
25479       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25480     } catch (std::out_of_range& e) {
25481       {
25482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25483       };
25484     } catch (std::exception& e) {
25485       {
25486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (Dali::DaliException e) {
25489       {
25490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25491       };
25492     } catch (...) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25495       };
25496     }
25497   }
25498
25499   jresult = (void *)result;
25500   return jresult;
25501 }
25502
25503
25504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25505   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25506
25507   arg1 = (Dali::PropertyBuffer *)jarg1;
25508   {
25509     try {
25510       delete arg1;
25511     } catch (std::out_of_range& e) {
25512       {
25513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (std::exception& e) {
25516       {
25517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25518       };
25519     } catch (Dali::DaliException e) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25522       };
25523     } catch (...) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25526       };
25527     }
25528   }
25529
25530 }
25531
25532
25533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25534   void * jresult ;
25535   Dali::PropertyBuffer *arg1 = 0 ;
25536   Dali::PropertyBuffer *result = 0 ;
25537
25538   arg1 = (Dali::PropertyBuffer *)jarg1;
25539   if (!arg1) {
25540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25541     return 0;
25542   }
25543   {
25544     try {
25545       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (Dali::DaliException e) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25561       };
25562     }
25563   }
25564
25565   jresult = (void *)result;
25566   return jresult;
25567 }
25568
25569
25570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25571   void * jresult ;
25572   Dali::BaseHandle arg1 ;
25573   Dali::BaseHandle *argp1 ;
25574   Dali::PropertyBuffer result;
25575
25576   argp1 = (Dali::BaseHandle *)jarg1;
25577   if (!argp1) {
25578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25579     return 0;
25580   }
25581   arg1 = *argp1;
25582   {
25583     try {
25584       result = Dali::PropertyBuffer::DownCast(arg1);
25585     } catch (std::out_of_range& e) {
25586       {
25587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (std::exception& e) {
25590       {
25591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25592       };
25593     } catch (Dali::DaliException e) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25596       };
25597     } catch (...) {
25598       {
25599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25600       };
25601     }
25602   }
25603
25604   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25605   return jresult;
25606 }
25607
25608
25609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25610   void * jresult ;
25611   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25612   Dali::PropertyBuffer *arg2 = 0 ;
25613   Dali::PropertyBuffer *result = 0 ;
25614
25615   arg1 = (Dali::PropertyBuffer *)jarg1;
25616   arg2 = (Dali::PropertyBuffer *)jarg2;
25617   if (!arg2) {
25618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25619     return 0;
25620   }
25621   {
25622     try {
25623       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25631       };
25632     } catch (Dali::DaliException e) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25635       };
25636     } catch (...) {
25637       {
25638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25639       };
25640     }
25641   }
25642
25643   jresult = (void *)result;
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25649   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25650   void *arg2 = (void *) 0 ;
25651   std::size_t arg3 ;
25652
25653   arg1 = (Dali::PropertyBuffer *)jarg1;
25654   arg2 = jarg2;
25655   arg3 = (std::size_t)jarg3;
25656   {
25657     try {
25658       (arg1)->SetData((void const *)arg2,arg3);
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25666       };
25667     } catch (Dali::DaliException e) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25670       };
25671     } catch (...) {
25672       {
25673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25674       };
25675     }
25676   }
25677
25678 }
25679
25680
25681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25682   unsigned long jresult ;
25683   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25684   std::size_t result;
25685
25686   arg1 = (Dali::PropertyBuffer *)jarg1;
25687   {
25688     try {
25689       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25690     } catch (std::out_of_range& e) {
25691       {
25692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (std::exception& e) {
25695       {
25696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25697       };
25698     } catch (Dali::DaliException e) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25701       };
25702     } catch (...) {
25703       {
25704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25705       };
25706     }
25707   }
25708
25709   jresult = (unsigned long)result;
25710   return jresult;
25711 }
25712
25713
25714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25715   void * jresult ;
25716   Dali::Geometry result;
25717
25718   {
25719     try {
25720       result = Dali::Geometry::New();
25721     } catch (std::out_of_range& e) {
25722       {
25723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (std::exception& e) {
25726       {
25727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25728       };
25729     } catch (Dali::DaliException e) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25732       };
25733     } catch (...) {
25734       {
25735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25736       };
25737     }
25738   }
25739
25740   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25741   return jresult;
25742 }
25743
25744
25745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25746   void * jresult ;
25747   Dali::Geometry *result = 0 ;
25748
25749   {
25750     try {
25751       result = (Dali::Geometry *)new Dali::Geometry();
25752     } catch (std::out_of_range& e) {
25753       {
25754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (std::exception& e) {
25757       {
25758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25759       };
25760     } catch (Dali::DaliException e) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25763       };
25764     } catch (...) {
25765       {
25766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25767       };
25768     }
25769   }
25770
25771   jresult = (void *)result;
25772   return jresult;
25773 }
25774
25775
25776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25777   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25778
25779   arg1 = (Dali::Geometry *)jarg1;
25780   {
25781     try {
25782       delete arg1;
25783     } catch (std::out_of_range& e) {
25784       {
25785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (std::exception& e) {
25788       {
25789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25790       };
25791     } catch (Dali::DaliException e) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25794       };
25795     } catch (...) {
25796       {
25797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25798       };
25799     }
25800   }
25801
25802 }
25803
25804
25805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25806   void * jresult ;
25807   Dali::Geometry *arg1 = 0 ;
25808   Dali::Geometry *result = 0 ;
25809
25810   arg1 = (Dali::Geometry *)jarg1;
25811   if (!arg1) {
25812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25813     return 0;
25814   }
25815   {
25816     try {
25817       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25818     } catch (std::out_of_range& e) {
25819       {
25820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (std::exception& e) {
25823       {
25824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25825       };
25826     } catch (Dali::DaliException e) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25829       };
25830     } catch (...) {
25831       {
25832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25833       };
25834     }
25835   }
25836
25837   jresult = (void *)result;
25838   return jresult;
25839 }
25840
25841
25842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25843   void * jresult ;
25844   Dali::BaseHandle arg1 ;
25845   Dali::BaseHandle *argp1 ;
25846   Dali::Geometry result;
25847
25848   argp1 = (Dali::BaseHandle *)jarg1;
25849   if (!argp1) {
25850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25851     return 0;
25852   }
25853   arg1 = *argp1;
25854   {
25855     try {
25856       result = Dali::Geometry::DownCast(arg1);
25857     } catch (std::out_of_range& e) {
25858       {
25859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (std::exception& e) {
25862       {
25863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (Dali::DaliException e) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25868       };
25869     } catch (...) {
25870       {
25871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25872       };
25873     }
25874   }
25875
25876   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25877   return jresult;
25878 }
25879
25880
25881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25882   void * jresult ;
25883   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25884   Dali::Geometry *arg2 = 0 ;
25885   Dali::Geometry *result = 0 ;
25886
25887   arg1 = (Dali::Geometry *)jarg1;
25888   arg2 = (Dali::Geometry *)jarg2;
25889   if (!arg2) {
25890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25891     return 0;
25892   }
25893   {
25894     try {
25895       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (Dali::DaliException e) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25907       };
25908     } catch (...) {
25909       {
25910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25911       };
25912     }
25913   }
25914
25915   jresult = (void *)result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25921   unsigned long jresult ;
25922   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25923   Dali::PropertyBuffer *arg2 = 0 ;
25924   std::size_t result;
25925
25926   arg1 = (Dali::Geometry *)jarg1;
25927   arg2 = (Dali::PropertyBuffer *)jarg2;
25928   if (!arg2) {
25929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25930     return 0;
25931   }
25932   {
25933     try {
25934       result = (arg1)->AddVertexBuffer(*arg2);
25935     } catch (std::out_of_range& e) {
25936       {
25937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (std::exception& e) {
25940       {
25941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (Dali::DaliException e) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25950       };
25951     }
25952   }
25953
25954   jresult = (unsigned long)result;
25955   return jresult;
25956 }
25957
25958
25959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25960   unsigned long jresult ;
25961   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25962   std::size_t result;
25963
25964   arg1 = (Dali::Geometry *)jarg1;
25965   {
25966     try {
25967       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25968     } catch (std::out_of_range& e) {
25969       {
25970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (std::exception& e) {
25973       {
25974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25975       };
25976     } catch (Dali::DaliException e) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25979       };
25980     } catch (...) {
25981       {
25982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25983       };
25984     }
25985   }
25986
25987   jresult = (unsigned long)result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25993   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25994   std::size_t arg2 ;
25995
25996   arg1 = (Dali::Geometry *)jarg1;
25997   arg2 = (std::size_t)jarg2;
25998   {
25999     try {
26000       (arg1)->RemoveVertexBuffer(arg2);
26001     } catch (std::out_of_range& e) {
26002       {
26003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26004       };
26005     } catch (std::exception& e) {
26006       {
26007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26008       };
26009     } catch (Dali::DaliException e) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26012       };
26013     } catch (...) {
26014       {
26015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26016       };
26017     }
26018   }
26019
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26024   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26025   unsigned short *arg2 = (unsigned short *) 0 ;
26026   size_t arg3 ;
26027
26028   arg1 = (Dali::Geometry *)jarg1;
26029   arg2 = jarg2;
26030   arg3 = (size_t)jarg3;
26031   {
26032     try {
26033       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26034     } catch (std::out_of_range& e) {
26035       {
26036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26037       };
26038     } catch (std::exception& e) {
26039       {
26040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26041       };
26042     } catch (Dali::DaliException e) {
26043       {
26044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26045       };
26046     } catch (...) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26049       };
26050     }
26051   }
26052
26053
26054
26055 }
26056
26057
26058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26059   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26060   Dali::Geometry::Type arg2 ;
26061
26062   arg1 = (Dali::Geometry *)jarg1;
26063   arg2 = (Dali::Geometry::Type)jarg2;
26064   {
26065     try {
26066       (arg1)->SetType(arg2);
26067     } catch (std::out_of_range& e) {
26068       {
26069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26070       };
26071     } catch (std::exception& e) {
26072       {
26073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26074       };
26075     } catch (Dali::DaliException e) {
26076       {
26077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26078       };
26079     } catch (...) {
26080       {
26081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26082       };
26083     }
26084   }
26085
26086 }
26087
26088
26089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26090   int jresult ;
26091   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26092   Dali::Geometry::Type result;
26093
26094   arg1 = (Dali::Geometry *)jarg1;
26095   {
26096     try {
26097       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26098     } catch (std::out_of_range& e) {
26099       {
26100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (std::exception& e) {
26103       {
26104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26105       };
26106     } catch (Dali::DaliException e) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26109       };
26110     } catch (...) {
26111       {
26112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26113       };
26114     }
26115   }
26116
26117   jresult = (int)result;
26118   return jresult;
26119 }
26120
26121
26122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26123   void * jresult ;
26124   Dali::Shader::Hint *result = 0 ;
26125
26126   {
26127     try {
26128       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26129     } catch (std::out_of_range& e) {
26130       {
26131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26132       };
26133     } catch (std::exception& e) {
26134       {
26135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26136       };
26137     } catch (Dali::DaliException e) {
26138       {
26139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26140       };
26141     } catch (...) {
26142       {
26143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26144       };
26145     }
26146   }
26147
26148   jresult = (void *)result;
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26154   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26155
26156   arg1 = (Dali::Shader::Hint *)jarg1;
26157   {
26158     try {
26159       delete arg1;
26160     } catch (std::out_of_range& e) {
26161       {
26162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26163       };
26164     } catch (std::exception& e) {
26165       {
26166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26167       };
26168     } catch (Dali::DaliException e) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26171       };
26172     } catch (...) {
26173       {
26174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26175       };
26176     }
26177   }
26178
26179 }
26180
26181
26182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26183   int jresult ;
26184   int result;
26185
26186   result = (int)Dali::Shader::Property::PROGRAM;
26187   jresult = (int)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26193   void * jresult ;
26194   Dali::Shader::Property *result = 0 ;
26195
26196   {
26197     try {
26198       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26199     } catch (std::out_of_range& e) {
26200       {
26201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (std::exception& e) {
26204       {
26205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (Dali::DaliException e) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217
26218   jresult = (void *)result;
26219   return jresult;
26220 }
26221
26222
26223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26224   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26225
26226   arg1 = (Dali::Shader::Property *)jarg1;
26227   {
26228     try {
26229       delete arg1;
26230     } catch (std::out_of_range& e) {
26231       {
26232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (std::exception& e) {
26235       {
26236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26237       };
26238     } catch (Dali::DaliException e) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26241       };
26242     } catch (...) {
26243       {
26244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26245       };
26246     }
26247   }
26248
26249 }
26250
26251
26252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26253   void * jresult ;
26254   std::string *arg1 = 0 ;
26255   std::string *arg2 = 0 ;
26256   Dali::Shader::Hint::Value arg3 ;
26257   Dali::Shader result;
26258
26259   if (!jarg1) {
26260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26261     return 0;
26262   }
26263   std::string arg1_str(jarg1);
26264   arg1 = &arg1_str;
26265   if (!jarg2) {
26266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26267     return 0;
26268   }
26269   std::string arg2_str(jarg2);
26270   arg2 = &arg2_str;
26271   arg3 = (Dali::Shader::Hint::Value)jarg3;
26272   {
26273     try {
26274       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (Dali::DaliException e) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26286       };
26287     } catch (...) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26290       };
26291     }
26292   }
26293
26294   jresult = new Dali::Shader((const Dali::Shader &)result);
26295
26296   //argout typemap for const std::string&
26297
26298
26299   //argout typemap for const std::string&
26300
26301   return jresult;
26302 }
26303
26304
26305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26306   void * jresult ;
26307   std::string *arg1 = 0 ;
26308   std::string *arg2 = 0 ;
26309   Dali::Shader result;
26310
26311   if (!jarg1) {
26312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26313     return 0;
26314   }
26315   std::string arg1_str(jarg1);
26316   arg1 = &arg1_str;
26317   if (!jarg2) {
26318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26319     return 0;
26320   }
26321   std::string arg2_str(jarg2);
26322   arg2 = &arg2_str;
26323   {
26324     try {
26325       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26326     } catch (std::out_of_range& e) {
26327       {
26328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (std::exception& e) {
26331       {
26332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26333       };
26334     } catch (Dali::DaliException e) {
26335       {
26336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26337       };
26338     } catch (...) {
26339       {
26340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26341       };
26342     }
26343   }
26344
26345   jresult = new Dali::Shader((const Dali::Shader &)result);
26346
26347   //argout typemap for const std::string&
26348
26349
26350   //argout typemap for const std::string&
26351
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26357   void * jresult ;
26358   Dali::Shader *result = 0 ;
26359
26360   {
26361     try {
26362       result = (Dali::Shader *)new Dali::Shader();
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (Dali::DaliException e) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26374       };
26375     } catch (...) {
26376       {
26377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26378       };
26379     }
26380   }
26381
26382   jresult = (void *)result;
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26388   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26389
26390   arg1 = (Dali::Shader *)jarg1;
26391   {
26392     try {
26393       delete arg1;
26394     } catch (std::out_of_range& e) {
26395       {
26396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26397       };
26398     } catch (std::exception& e) {
26399       {
26400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26401       };
26402     } catch (Dali::DaliException e) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26405       };
26406     } catch (...) {
26407       {
26408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26409       };
26410     }
26411   }
26412
26413 }
26414
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26417   void * jresult ;
26418   Dali::Shader *arg1 = 0 ;
26419   Dali::Shader *result = 0 ;
26420
26421   arg1 = (Dali::Shader *)jarg1;
26422   if (!arg1) {
26423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26424     return 0;
26425   }
26426   {
26427     try {
26428       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26429     } catch (std::out_of_range& e) {
26430       {
26431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (std::exception& e) {
26434       {
26435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (Dali::DaliException e) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26440       };
26441     } catch (...) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26444       };
26445     }
26446   }
26447
26448   jresult = (void *)result;
26449   return jresult;
26450 }
26451
26452
26453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26454   void * jresult ;
26455   Dali::BaseHandle arg1 ;
26456   Dali::BaseHandle *argp1 ;
26457   Dali::Shader result;
26458
26459   argp1 = (Dali::BaseHandle *)jarg1;
26460   if (!argp1) {
26461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26462     return 0;
26463   }
26464   arg1 = *argp1;
26465   {
26466     try {
26467       result = Dali::Shader::DownCast(arg1);
26468     } catch (std::out_of_range& e) {
26469       {
26470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26471       };
26472     } catch (std::exception& e) {
26473       {
26474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26475       };
26476     } catch (Dali::DaliException e) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26479       };
26480     } catch (...) {
26481       {
26482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26483       };
26484     }
26485   }
26486
26487   jresult = new Dali::Shader((const Dali::Shader &)result);
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26493   void * jresult ;
26494   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26495   Dali::Shader *arg2 = 0 ;
26496   Dali::Shader *result = 0 ;
26497
26498   arg1 = (Dali::Shader *)jarg1;
26499   arg2 = (Dali::Shader *)jarg2;
26500   if (!arg2) {
26501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26502     return 0;
26503   }
26504   {
26505     try {
26506       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26507     } catch (std::out_of_range& e) {
26508       {
26509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26510       };
26511     } catch (std::exception& e) {
26512       {
26513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26514       };
26515     } catch (Dali::DaliException e) {
26516       {
26517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26518       };
26519     } catch (...) {
26520       {
26521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26522       };
26523     }
26524   }
26525
26526   jresult = (void *)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26532   int jresult ;
26533   int result;
26534
26535   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26536   jresult = (int)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26542   int jresult ;
26543   int result;
26544
26545   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26546   jresult = (int)result;
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26552   int jresult ;
26553   int result;
26554
26555   result = (int)Dali::Renderer::Property::BLEND_MODE;
26556   jresult = (int)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26562   int jresult ;
26563   int result;
26564
26565   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26566   jresult = (int)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26572   int jresult ;
26573   int result;
26574
26575   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26576   jresult = (int)result;
26577   return jresult;
26578 }
26579
26580
26581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26582   int jresult ;
26583   int result;
26584
26585   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26586   jresult = (int)result;
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26592   int jresult ;
26593   int result;
26594
26595   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26596   jresult = (int)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26602   int jresult ;
26603   int result;
26604
26605   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26606   jresult = (int)result;
26607   return jresult;
26608 }
26609
26610
26611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26612   int jresult ;
26613   int result;
26614
26615   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26616   jresult = (int)result;
26617   return jresult;
26618 }
26619
26620
26621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26622   int jresult ;
26623   int result;
26624
26625   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26626   jresult = (int)result;
26627   return jresult;
26628 }
26629
26630
26631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26632   int jresult ;
26633   int result;
26634
26635   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26636   jresult = (int)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26642   int jresult ;
26643   int result;
26644
26645   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26646   jresult = (int)result;
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26652   int jresult ;
26653   int result;
26654
26655   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26656   jresult = (int)result;
26657   return jresult;
26658 }
26659
26660
26661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26662   int jresult ;
26663   int result;
26664
26665   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26666   jresult = (int)result;
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26672   int jresult ;
26673   int result;
26674
26675   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26676   jresult = (int)result;
26677   return jresult;
26678 }
26679
26680
26681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26682   int jresult ;
26683   int result;
26684
26685   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26686   jresult = (int)result;
26687   return jresult;
26688 }
26689
26690
26691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26692   int jresult ;
26693   int result;
26694
26695   result = (int)Dali::Renderer::Property::RENDER_MODE;
26696   jresult = (int)result;
26697   return jresult;
26698 }
26699
26700
26701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26702   int jresult ;
26703   int result;
26704
26705   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26706   jresult = (int)result;
26707   return jresult;
26708 }
26709
26710
26711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26712   int jresult ;
26713   int result;
26714
26715   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26716   jresult = (int)result;
26717   return jresult;
26718 }
26719
26720
26721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26722   int jresult ;
26723   int result;
26724
26725   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26726   jresult = (int)result;
26727   return jresult;
26728 }
26729
26730
26731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26732   int jresult ;
26733   int result;
26734
26735   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26736   jresult = (int)result;
26737   return jresult;
26738 }
26739
26740
26741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26742   int jresult ;
26743   int result;
26744
26745   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26746   jresult = (int)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26752   int jresult ;
26753   int result;
26754
26755   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26756   jresult = (int)result;
26757   return jresult;
26758 }
26759
26760
26761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26762   int jresult ;
26763   int result;
26764
26765   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26766   jresult = (int)result;
26767   return jresult;
26768 }
26769
26770
26771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26772   void * jresult ;
26773   Dali::Renderer::Property *result = 0 ;
26774
26775   {
26776     try {
26777       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26778     } catch (std::out_of_range& e) {
26779       {
26780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (std::exception& e) {
26783       {
26784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26785       };
26786     } catch (Dali::DaliException e) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26789       };
26790     } catch (...) {
26791       {
26792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26793       };
26794     }
26795   }
26796
26797   jresult = (void *)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26803   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26804
26805   arg1 = (Dali::Renderer::Property *)jarg1;
26806   {
26807     try {
26808       delete arg1;
26809     } catch (std::out_of_range& e) {
26810       {
26811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26812       };
26813     } catch (std::exception& e) {
26814       {
26815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (Dali::DaliException e) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827
26828 }
26829
26830
26831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26832   void * jresult ;
26833   Dali::Geometry *arg1 = 0 ;
26834   Dali::Shader *arg2 = 0 ;
26835   Dali::Renderer result;
26836
26837   arg1 = (Dali::Geometry *)jarg1;
26838   if (!arg1) {
26839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26840     return 0;
26841   }
26842   arg2 = (Dali::Shader *)jarg2;
26843   if (!arg2) {
26844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26845     return 0;
26846   }
26847   {
26848     try {
26849       result = Dali::Renderer::New(*arg1,*arg2);
26850     } catch (std::out_of_range& e) {
26851       {
26852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (std::exception& e) {
26855       {
26856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26857       };
26858     } catch (Dali::DaliException e) {
26859       {
26860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26861       };
26862     } catch (...) {
26863       {
26864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26865       };
26866     }
26867   }
26868
26869   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26875   void * jresult ;
26876   Dali::Renderer *result = 0 ;
26877
26878   {
26879     try {
26880       result = (Dali::Renderer *)new Dali::Renderer();
26881     } catch (std::out_of_range& e) {
26882       {
26883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (std::exception& e) {
26886       {
26887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (Dali::DaliException e) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26892       };
26893     } catch (...) {
26894       {
26895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26896       };
26897     }
26898   }
26899
26900   jresult = (void *)result;
26901   return jresult;
26902 }
26903
26904
26905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26906   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26907
26908   arg1 = (Dali::Renderer *)jarg1;
26909   {
26910     try {
26911       delete arg1;
26912     } catch (std::out_of_range& e) {
26913       {
26914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26915       };
26916     } catch (std::exception& e) {
26917       {
26918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26919       };
26920     } catch (Dali::DaliException e) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26923       };
26924     } catch (...) {
26925       {
26926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26927       };
26928     }
26929   }
26930
26931 }
26932
26933
26934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26935   void * jresult ;
26936   Dali::Renderer *arg1 = 0 ;
26937   Dali::Renderer *result = 0 ;
26938
26939   arg1 = (Dali::Renderer *)jarg1;
26940   if (!arg1) {
26941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26942     return 0;
26943   }
26944   {
26945     try {
26946       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26947     } catch (std::out_of_range& e) {
26948       {
26949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26950       };
26951     } catch (std::exception& e) {
26952       {
26953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26954       };
26955     } catch (Dali::DaliException e) {
26956       {
26957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26958       };
26959     } catch (...) {
26960       {
26961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26962       };
26963     }
26964   }
26965
26966   jresult = (void *)result;
26967   return jresult;
26968 }
26969
26970
26971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26972   void * jresult ;
26973   Dali::BaseHandle arg1 ;
26974   Dali::BaseHandle *argp1 ;
26975   Dali::Renderer result;
26976
26977   argp1 = (Dali::BaseHandle *)jarg1;
26978   if (!argp1) {
26979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26980     return 0;
26981   }
26982   arg1 = *argp1;
26983   {
26984     try {
26985       result = Dali::Renderer::DownCast(arg1);
26986     } catch (std::out_of_range& e) {
26987       {
26988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26989       };
26990     } catch (std::exception& e) {
26991       {
26992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26993       };
26994     } catch (Dali::DaliException e) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26997       };
26998     } catch (...) {
26999       {
27000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27001       };
27002     }
27003   }
27004
27005   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27006   return jresult;
27007 }
27008
27009
27010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27011   void * jresult ;
27012   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27013   Dali::Renderer *arg2 = 0 ;
27014   Dali::Renderer *result = 0 ;
27015
27016   arg1 = (Dali::Renderer *)jarg1;
27017   arg2 = (Dali::Renderer *)jarg2;
27018   if (!arg2) {
27019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27020     return 0;
27021   }
27022   {
27023     try {
27024       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27025     } catch (std::out_of_range& e) {
27026       {
27027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (std::exception& e) {
27030       {
27031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27032       };
27033     } catch (Dali::DaliException e) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27036       };
27037     } catch (...) {
27038       {
27039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27040       };
27041     }
27042   }
27043
27044   jresult = (void *)result;
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27050   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27051   Dali::Geometry *arg2 = 0 ;
27052
27053   arg1 = (Dali::Renderer *)jarg1;
27054   arg2 = (Dali::Geometry *)jarg2;
27055   if (!arg2) {
27056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27057     return ;
27058   }
27059   {
27060     try {
27061       (arg1)->SetGeometry(*arg2);
27062     } catch (std::out_of_range& e) {
27063       {
27064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (std::exception& e) {
27067       {
27068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27069       };
27070     } catch (Dali::DaliException e) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27073       };
27074     } catch (...) {
27075       {
27076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27077       };
27078     }
27079   }
27080
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27085   void * jresult ;
27086   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27087   Dali::Geometry result;
27088
27089   arg1 = (Dali::Renderer *)jarg1;
27090   {
27091     try {
27092       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27093     } catch (std::out_of_range& e) {
27094       {
27095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (std::exception& e) {
27098       {
27099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27100       };
27101     } catch (Dali::DaliException e) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27104       };
27105     } catch (...) {
27106       {
27107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27108       };
27109     }
27110   }
27111
27112   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27113   return jresult;
27114 }
27115
27116
27117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27118   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27119   int arg2 ;
27120   int arg3 ;
27121
27122   arg1 = (Dali::Renderer *)jarg1;
27123   arg2 = (int)jarg2;
27124   arg3 = (int)jarg3;
27125   {
27126     try {
27127       (arg1)->SetIndexRange(arg2,arg3);
27128     } catch (std::out_of_range& e) {
27129       {
27130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27131       };
27132     } catch (std::exception& e) {
27133       {
27134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27135       };
27136     } catch (Dali::DaliException e) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27139       };
27140     } catch (...) {
27141       {
27142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27143       };
27144     }
27145   }
27146
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27151   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27152   Dali::TextureSet *arg2 = 0 ;
27153
27154   arg1 = (Dali::Renderer *)jarg1;
27155   arg2 = (Dali::TextureSet *)jarg2;
27156   if (!arg2) {
27157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27158     return ;
27159   }
27160   {
27161     try {
27162       (arg1)->SetTextures(*arg2);
27163     } catch (std::out_of_range& e) {
27164       {
27165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27166       };
27167     } catch (std::exception& e) {
27168       {
27169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27170       };
27171     } catch (Dali::DaliException e) {
27172       {
27173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27174       };
27175     } catch (...) {
27176       {
27177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27178       };
27179     }
27180   }
27181
27182 }
27183
27184
27185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27186   void * jresult ;
27187   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27188   Dali::TextureSet result;
27189
27190   arg1 = (Dali::Renderer *)jarg1;
27191   {
27192     try {
27193       result = ((Dali::Renderer const *)arg1)->GetTextures();
27194     } catch (std::out_of_range& e) {
27195       {
27196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (std::exception& e) {
27199       {
27200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27201       };
27202     } catch (Dali::DaliException e) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27205       };
27206     } catch (...) {
27207       {
27208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27209       };
27210     }
27211   }
27212
27213   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27214   return jresult;
27215 }
27216
27217
27218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27219   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27220   Dali::Shader *arg2 = 0 ;
27221
27222   arg1 = (Dali::Renderer *)jarg1;
27223   arg2 = (Dali::Shader *)jarg2;
27224   if (!arg2) {
27225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27226     return ;
27227   }
27228   {
27229     try {
27230       (arg1)->SetShader(*arg2);
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27238       };
27239     } catch (Dali::DaliException e) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27242       };
27243     } catch (...) {
27244       {
27245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27246       };
27247     }
27248   }
27249
27250 }
27251
27252
27253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27254   void * jresult ;
27255   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27256   Dali::Shader result;
27257
27258   arg1 = (Dali::Renderer *)jarg1;
27259   {
27260     try {
27261       result = ((Dali::Renderer const *)arg1)->GetShader();
27262     } catch (std::out_of_range& e) {
27263       {
27264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (std::exception& e) {
27267       {
27268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27269       };
27270     } catch (Dali::DaliException e) {
27271       {
27272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27273       };
27274     } catch (...) {
27275       {
27276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27277       };
27278     }
27279   }
27280
27281   jresult = new Dali::Shader((const Dali::Shader &)result);
27282   return jresult;
27283 }
27284
27285
27286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27287   void * jresult ;
27288   Dali::FrameBuffer::Attachment *result = 0 ;
27289
27290   {
27291     try {
27292       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27293     } catch (std::out_of_range& e) {
27294       {
27295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (std::exception& e) {
27298       {
27299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27300       };
27301     } catch (Dali::DaliException e) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27304       };
27305     } catch (...) {
27306       {
27307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27308       };
27309     }
27310   }
27311
27312   jresult = (void *)result;
27313   return jresult;
27314 }
27315
27316
27317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27318   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27319
27320   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27321   {
27322     try {
27323       delete arg1;
27324     } catch (std::out_of_range& e) {
27325       {
27326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27327       };
27328     } catch (std::exception& e) {
27329       {
27330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27331       };
27332     } catch (Dali::DaliException e) {
27333       {
27334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27335       };
27336     } catch (...) {
27337       {
27338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27339       };
27340     }
27341   }
27342
27343 }
27344
27345
27346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27347   void * jresult ;
27348   unsigned int arg1 ;
27349   unsigned int arg2 ;
27350   unsigned int arg3 ;
27351   Dali::FrameBuffer result;
27352
27353   arg1 = (unsigned int)jarg1;
27354   arg2 = (unsigned int)jarg2;
27355   arg3 = (unsigned int)jarg3;
27356   {
27357     try {
27358       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27359     } catch (std::out_of_range& e) {
27360       {
27361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (std::exception& e) {
27364       {
27365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27366       };
27367     } catch (Dali::DaliException e) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27370       };
27371     } catch (...) {
27372       {
27373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27374       };
27375     }
27376   }
27377
27378   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27379   return jresult;
27380 }
27381
27382
27383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27384   void * jresult ;
27385   Dali::FrameBuffer *result = 0 ;
27386
27387   {
27388     try {
27389       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27390     } catch (std::out_of_range& e) {
27391       {
27392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27393       };
27394     } catch (std::exception& e) {
27395       {
27396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27397       };
27398     } catch (Dali::DaliException e) {
27399       {
27400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27401       };
27402     } catch (...) {
27403       {
27404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27405       };
27406     }
27407   }
27408
27409   jresult = (void *)result;
27410   return jresult;
27411 }
27412
27413
27414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27415   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27416
27417   arg1 = (Dali::FrameBuffer *)jarg1;
27418   {
27419     try {
27420       delete arg1;
27421     } catch (std::out_of_range& e) {
27422       {
27423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27424       };
27425     } catch (std::exception& e) {
27426       {
27427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27428       };
27429     } catch (Dali::DaliException e) {
27430       {
27431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27432       };
27433     } catch (...) {
27434       {
27435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27436       };
27437     }
27438   }
27439
27440 }
27441
27442
27443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27444   void * jresult ;
27445   Dali::FrameBuffer *arg1 = 0 ;
27446   Dali::FrameBuffer *result = 0 ;
27447
27448   arg1 = (Dali::FrameBuffer *)jarg1;
27449   if (!arg1) {
27450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27451     return 0;
27452   }
27453   {
27454     try {
27455       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27456     } catch (std::out_of_range& e) {
27457       {
27458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (std::exception& e) {
27461       {
27462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (Dali::DaliException e) {
27465       {
27466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474
27475   jresult = (void *)result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27481   void * jresult ;
27482   Dali::BaseHandle arg1 ;
27483   Dali::BaseHandle *argp1 ;
27484   Dali::FrameBuffer result;
27485
27486   argp1 = (Dali::BaseHandle *)jarg1;
27487   if (!argp1) {
27488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27489     return 0;
27490   }
27491   arg1 = *argp1;
27492   {
27493     try {
27494       result = Dali::FrameBuffer::DownCast(arg1);
27495     } catch (std::out_of_range& e) {
27496       {
27497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27498       };
27499     } catch (std::exception& e) {
27500       {
27501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27502       };
27503     } catch (Dali::DaliException e) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27506       };
27507     } catch (...) {
27508       {
27509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27510       };
27511     }
27512   }
27513
27514   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27515   return jresult;
27516 }
27517
27518
27519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27520   void * jresult ;
27521   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27522   Dali::FrameBuffer *arg2 = 0 ;
27523   Dali::FrameBuffer *result = 0 ;
27524
27525   arg1 = (Dali::FrameBuffer *)jarg1;
27526   arg2 = (Dali::FrameBuffer *)jarg2;
27527   if (!arg2) {
27528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27529     return 0;
27530   }
27531   {
27532     try {
27533       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27541       };
27542     } catch (Dali::DaliException e) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27545       };
27546     } catch (...) {
27547       {
27548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27549       };
27550     }
27551   }
27552
27553   jresult = (void *)result;
27554   return jresult;
27555 }
27556
27557
27558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27559   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27560   Dali::Texture *arg2 = 0 ;
27561
27562   arg1 = (Dali::FrameBuffer *)jarg1;
27563   arg2 = (Dali::Texture *)jarg2;
27564   if (!arg2) {
27565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27566     return ;
27567   }
27568   {
27569     try {
27570       (arg1)->AttachColorTexture(*arg2);
27571     } catch (std::out_of_range& e) {
27572       {
27573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27574       };
27575     } catch (std::exception& e) {
27576       {
27577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27578       };
27579     } catch (Dali::DaliException e) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27582       };
27583     } catch (...) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27586       };
27587     }
27588   }
27589
27590 }
27591
27592
27593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27594   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27595   Dali::Texture *arg2 = 0 ;
27596   unsigned int arg3 ;
27597   unsigned int arg4 ;
27598
27599   arg1 = (Dali::FrameBuffer *)jarg1;
27600   arg2 = (Dali::Texture *)jarg2;
27601   if (!arg2) {
27602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27603     return ;
27604   }
27605   arg3 = (unsigned int)jarg3;
27606   arg4 = (unsigned int)jarg4;
27607   {
27608     try {
27609       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27610     } catch (std::out_of_range& e) {
27611       {
27612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27613       };
27614     } catch (std::exception& e) {
27615       {
27616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27617       };
27618     } catch (Dali::DaliException e) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27625       };
27626     }
27627   }
27628
27629 }
27630
27631
27632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27633   void * jresult ;
27634   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27635   Dali::Texture result;
27636
27637   arg1 = (Dali::FrameBuffer *)jarg1;
27638   {
27639     try {
27640       result = (arg1)->GetColorTexture();
27641     } catch (std::out_of_range& e) {
27642       {
27643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (std::exception& e) {
27646       {
27647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27648       };
27649     } catch (Dali::DaliException e) {
27650       {
27651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27652       };
27653     } catch (...) {
27654       {
27655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27656       };
27657     }
27658   }
27659
27660   jresult = new Dali::Texture((const Dali::Texture &)result);
27661   return jresult;
27662 }
27663
27664
27665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27666   void * jresult ;
27667   Dali::RenderTaskList *result = 0 ;
27668
27669   {
27670     try {
27671       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27672     } catch (std::out_of_range& e) {
27673       {
27674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (std::exception& e) {
27677       {
27678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27679       };
27680     } catch (Dali::DaliException e) {
27681       {
27682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27683       };
27684     } catch (...) {
27685       {
27686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27687       };
27688     }
27689   }
27690
27691   jresult = (void *)result;
27692   return jresult;
27693 }
27694
27695
27696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27697   void * jresult ;
27698   Dali::BaseHandle arg1 ;
27699   Dali::BaseHandle *argp1 ;
27700   Dali::RenderTaskList result;
27701
27702   argp1 = (Dali::BaseHandle *)jarg1;
27703   if (!argp1) {
27704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27705     return 0;
27706   }
27707   arg1 = *argp1;
27708   {
27709     try {
27710       result = Dali::RenderTaskList::DownCast(arg1);
27711     } catch (std::out_of_range& e) {
27712       {
27713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (std::exception& e) {
27716       {
27717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27718       };
27719     } catch (Dali::DaliException e) {
27720       {
27721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27722       };
27723     } catch (...) {
27724       {
27725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27726       };
27727     }
27728   }
27729
27730   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27736   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27737
27738   arg1 = (Dali::RenderTaskList *)jarg1;
27739   {
27740     try {
27741       delete arg1;
27742     } catch (std::out_of_range& e) {
27743       {
27744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27745       };
27746     } catch (std::exception& e) {
27747       {
27748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27749       };
27750     } catch (Dali::DaliException e) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27753       };
27754     } catch (...) {
27755       {
27756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27757       };
27758     }
27759   }
27760
27761 }
27762
27763
27764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27765   void * jresult ;
27766   Dali::RenderTaskList *arg1 = 0 ;
27767   Dali::RenderTaskList *result = 0 ;
27768
27769   arg1 = (Dali::RenderTaskList *)jarg1;
27770   if (!arg1) {
27771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27772     return 0;
27773   }
27774   {
27775     try {
27776       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27784       };
27785     } catch (Dali::DaliException e) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27788       };
27789     } catch (...) {
27790       {
27791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27792       };
27793     }
27794   }
27795
27796   jresult = (void *)result;
27797   return jresult;
27798 }
27799
27800
27801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27802   void * jresult ;
27803   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27804   Dali::RenderTaskList *arg2 = 0 ;
27805   Dali::RenderTaskList *result = 0 ;
27806
27807   arg1 = (Dali::RenderTaskList *)jarg1;
27808   arg2 = (Dali::RenderTaskList *)jarg2;
27809   if (!arg2) {
27810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27811     return 0;
27812   }
27813   {
27814     try {
27815       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27816     } catch (std::out_of_range& e) {
27817       {
27818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27819       };
27820     } catch (std::exception& e) {
27821       {
27822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27823       };
27824     } catch (Dali::DaliException e) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27827       };
27828     } catch (...) {
27829       {
27830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27831       };
27832     }
27833   }
27834
27835   jresult = (void *)result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27841   void * jresult ;
27842   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27843   Dali::RenderTask result;
27844
27845   arg1 = (Dali::RenderTaskList *)jarg1;
27846   {
27847     try {
27848       result = (arg1)->CreateTask();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (Dali::DaliException e) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27860       };
27861     } catch (...) {
27862       {
27863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27864       };
27865     }
27866   }
27867
27868   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27869   return jresult;
27870 }
27871
27872
27873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27874   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27875   Dali::RenderTask arg2 ;
27876   Dali::RenderTask *argp2 ;
27877
27878   arg1 = (Dali::RenderTaskList *)jarg1;
27879   argp2 = (Dali::RenderTask *)jarg2;
27880   if (!argp2) {
27881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27882     return ;
27883   }
27884   arg2 = *argp2;
27885   {
27886     try {
27887       (arg1)->RemoveTask(arg2);
27888     } catch (std::out_of_range& e) {
27889       {
27890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27891       };
27892     } catch (std::exception& e) {
27893       {
27894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27895       };
27896     } catch (Dali::DaliException e) {
27897       {
27898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27899       };
27900     } catch (...) {
27901       {
27902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27903       };
27904     }
27905   }
27906
27907 }
27908
27909
27910 //// ===============================================end part 1 =================
27911
27912 //// ========================= part 2 ===============================
27913
27914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27915   unsigned int jresult ;
27916   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27917   unsigned int result;
27918
27919   arg1 = (Dali::RenderTaskList *)jarg1;
27920   {
27921     try {
27922       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27923     } catch (std::out_of_range& e) {
27924       {
27925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (std::exception& e) {
27928       {
27929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (Dali::DaliException e) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27934       };
27935     } catch (...) {
27936       {
27937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27938       };
27939     }
27940   }
27941
27942   jresult = result;
27943   return jresult;
27944 }
27945
27946
27947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27948   void * jresult ;
27949   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27950   unsigned int arg2 ;
27951   Dali::RenderTask result;
27952
27953   arg1 = (Dali::RenderTaskList *)jarg1;
27954   arg2 = (unsigned int)jarg2;
27955   {
27956     try {
27957       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27958     } catch (std::out_of_range& e) {
27959       {
27960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (std::exception& e) {
27963       {
27964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27965       };
27966     } catch (Dali::DaliException e) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27969       };
27970     } catch (...) {
27971       {
27972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27973       };
27974     }
27975   }
27976
27977   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27978   return jresult;
27979 }
27980
27981
27982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27983   int jresult ;
27984   int result;
27985
27986   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27987   jresult = (int)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27993   int jresult ;
27994   int result;
27995
27996   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27997   jresult = (int)result;
27998   return jresult;
27999 }
28000
28001
28002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28003   int jresult ;
28004   int result;
28005
28006   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28007   jresult = (int)result;
28008   return jresult;
28009 }
28010
28011
28012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28013   int jresult ;
28014   int result;
28015
28016   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28017   jresult = (int)result;
28018   return jresult;
28019 }
28020
28021
28022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28023   void * jresult ;
28024   Dali::RenderTask::Property *result = 0 ;
28025
28026   {
28027     try {
28028       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28029     } catch (std::out_of_range& e) {
28030       {
28031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28032       };
28033     } catch (std::exception& e) {
28034       {
28035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28036       };
28037     } catch (Dali::DaliException e) {
28038       {
28039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28040       };
28041     } catch (...) {
28042       {
28043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28044       };
28045     }
28046   }
28047
28048   jresult = (void *)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28054   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28055
28056   arg1 = (Dali::RenderTask::Property *)jarg1;
28057   {
28058     try {
28059       delete arg1;
28060     } catch (std::out_of_range& e) {
28061       {
28062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28063       };
28064     } catch (std::exception& e) {
28065       {
28066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28067       };
28068     } catch (Dali::DaliException e) {
28069       {
28070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28071       };
28072     } catch (...) {
28073       {
28074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28075       };
28076     }
28077   }
28078
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28083   void * jresult ;
28084   bool (*result)(Dali::Vector2 &) = 0 ;
28085
28086   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28087   jresult = (void *)result;
28088   return jresult;
28089 }
28090
28091
28092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28093   void * jresult ;
28094   bool (*result)(Dali::Vector2 &) = 0 ;
28095
28096   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28097   jresult = (void *)result;
28098   return jresult;
28099 }
28100
28101
28102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28103   unsigned int jresult ;
28104   bool result;
28105
28106   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28107   jresult = result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28113   unsigned int jresult ;
28114   bool result;
28115
28116   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28117   jresult = result;
28118   return jresult;
28119 }
28120
28121
28122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28123   void * jresult ;
28124   Dali::Vector4 *result = 0 ;
28125
28126   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28127   jresult = (void *)result;
28128   return jresult;
28129 }
28130
28131
28132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28133   unsigned int jresult ;
28134   bool result;
28135
28136   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28137   jresult = result;
28138   return jresult;
28139 }
28140
28141
28142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28143   unsigned int jresult ;
28144   bool result;
28145
28146   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28147   jresult = result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28153   unsigned int jresult ;
28154   unsigned int result;
28155
28156   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28157   jresult = result;
28158   return jresult;
28159 }
28160
28161
28162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28163   void * jresult ;
28164   Dali::RenderTask *result = 0 ;
28165
28166   {
28167     try {
28168       result = (Dali::RenderTask *)new Dali::RenderTask();
28169     } catch (std::out_of_range& e) {
28170       {
28171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (std::exception& e) {
28174       {
28175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28176       };
28177     } catch (Dali::DaliException e) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28180       };
28181     } catch (...) {
28182       {
28183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28184       };
28185     }
28186   }
28187
28188   jresult = (void *)result;
28189   return jresult;
28190 }
28191
28192
28193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28194   void * jresult ;
28195   Dali::BaseHandle arg1 ;
28196   Dali::BaseHandle *argp1 ;
28197   Dali::RenderTask result;
28198
28199   argp1 = (Dali::BaseHandle *)jarg1;
28200   if (!argp1) {
28201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28202     return 0;
28203   }
28204   arg1 = *argp1;
28205   {
28206     try {
28207       result = Dali::RenderTask::DownCast(arg1);
28208     } catch (std::out_of_range& e) {
28209       {
28210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28211       };
28212     } catch (std::exception& e) {
28213       {
28214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28215       };
28216     } catch (Dali::DaliException e) {
28217       {
28218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28219       };
28220     } catch (...) {
28221       {
28222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28223       };
28224     }
28225   }
28226
28227   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28233   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28234
28235   arg1 = (Dali::RenderTask *)jarg1;
28236   {
28237     try {
28238       delete arg1;
28239     } catch (std::out_of_range& e) {
28240       {
28241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28242       };
28243     } catch (std::exception& e) {
28244       {
28245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28246       };
28247     } catch (Dali::DaliException e) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28250       };
28251     } catch (...) {
28252       {
28253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28254       };
28255     }
28256   }
28257
28258 }
28259
28260
28261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28262   void * jresult ;
28263   Dali::RenderTask *arg1 = 0 ;
28264   Dali::RenderTask *result = 0 ;
28265
28266   arg1 = (Dali::RenderTask *)jarg1;
28267   if (!arg1) {
28268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28269     return 0;
28270   }
28271   {
28272     try {
28273       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28274     } catch (std::out_of_range& e) {
28275       {
28276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28277       };
28278     } catch (std::exception& e) {
28279       {
28280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28281       };
28282     } catch (Dali::DaliException e) {
28283       {
28284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28285       };
28286     } catch (...) {
28287       {
28288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28289       };
28290     }
28291   }
28292
28293   jresult = (void *)result;
28294   return jresult;
28295 }
28296
28297
28298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28299   void * jresult ;
28300   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28301   Dali::RenderTask *arg2 = 0 ;
28302   Dali::RenderTask *result = 0 ;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   arg2 = (Dali::RenderTask *)jarg2;
28306   if (!arg2) {
28307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28308     return 0;
28309   }
28310   {
28311     try {
28312       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28320       };
28321     } catch (Dali::DaliException e) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28324       };
28325     } catch (...) {
28326       {
28327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28328       };
28329     }
28330   }
28331
28332   jresult = (void *)result;
28333   return jresult;
28334 }
28335
28336
28337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28338   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28339   Dali::Actor arg2 ;
28340   Dali::Actor *argp2 ;
28341
28342   arg1 = (Dali::RenderTask *)jarg1;
28343   argp2 = (Dali::Actor *)jarg2;
28344   if (!argp2) {
28345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28346     return ;
28347   }
28348   arg2 = *argp2;
28349   {
28350     try {
28351       (arg1)->SetSourceActor(arg2);
28352     } catch (std::out_of_range& e) {
28353       {
28354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (std::exception& e) {
28357       {
28358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28359       };
28360     } catch (Dali::DaliException e) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28363       };
28364     } catch (...) {
28365       {
28366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28367       };
28368     }
28369   }
28370
28371 }
28372
28373
28374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28375   void * jresult ;
28376   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28377   Dali::Actor result;
28378
28379   arg1 = (Dali::RenderTask *)jarg1;
28380   {
28381     try {
28382       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28383     } catch (std::out_of_range& e) {
28384       {
28385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (std::exception& e) {
28388       {
28389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28390       };
28391     } catch (Dali::DaliException e) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28394       };
28395     } catch (...) {
28396       {
28397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28398       };
28399     }
28400   }
28401
28402   jresult = new Dali::Actor((const Dali::Actor &)result);
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28409   bool arg2 ;
28410
28411   arg1 = (Dali::RenderTask *)jarg1;
28412   arg2 = jarg2 ? true : false;
28413   {
28414     try {
28415       (arg1)->SetExclusive(arg2);
28416     } catch (std::out_of_range& e) {
28417       {
28418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (std::exception& e) {
28421       {
28422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28423       };
28424     } catch (Dali::DaliException e) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28427       };
28428     } catch (...) {
28429       {
28430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28431       };
28432     }
28433   }
28434
28435 }
28436
28437
28438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28439   unsigned int jresult ;
28440   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28441   bool result;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   {
28445     try {
28446       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28447     } catch (std::out_of_range& e) {
28448       {
28449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (std::exception& e) {
28452       {
28453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28454       };
28455     } catch (Dali::DaliException e) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28458       };
28459     } catch (...) {
28460       {
28461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28462       };
28463     }
28464   }
28465
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28473   bool arg2 ;
28474
28475   arg1 = (Dali::RenderTask *)jarg1;
28476   arg2 = jarg2 ? true : false;
28477   {
28478     try {
28479       (arg1)->SetInputEnabled(arg2);
28480     } catch (std::out_of_range& e) {
28481       {
28482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (std::exception& e) {
28485       {
28486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28487       };
28488     } catch (Dali::DaliException e) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28491       };
28492     } catch (...) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28495       };
28496     }
28497   }
28498
28499 }
28500
28501
28502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28503   unsigned int jresult ;
28504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28505   bool result;
28506
28507   arg1 = (Dali::RenderTask *)jarg1;
28508   {
28509     try {
28510       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28511     } catch (std::out_of_range& e) {
28512       {
28513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (std::exception& e) {
28516       {
28517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28518       };
28519     } catch (Dali::DaliException e) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28526       };
28527     }
28528   }
28529
28530   jresult = result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28536   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28537   Dali::CameraActor arg2 ;
28538   Dali::CameraActor *argp2 ;
28539
28540   arg1 = (Dali::RenderTask *)jarg1;
28541   argp2 = (Dali::CameraActor *)jarg2;
28542   if (!argp2) {
28543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28544     return ;
28545   }
28546   arg2 = *argp2;
28547   {
28548     try {
28549       (arg1)->SetCameraActor(arg2);
28550     } catch (std::out_of_range& e) {
28551       {
28552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (std::exception& e) {
28555       {
28556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28557       };
28558     } catch (Dali::DaliException e) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28561       };
28562     } catch (...) {
28563       {
28564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28565       };
28566     }
28567   }
28568
28569 }
28570
28571
28572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28573   void * jresult ;
28574   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28575   Dali::CameraActor result;
28576
28577   arg1 = (Dali::RenderTask *)jarg1;
28578   {
28579     try {
28580       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28581     } catch (std::out_of_range& e) {
28582       {
28583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (std::exception& e) {
28586       {
28587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28588       };
28589     } catch (Dali::DaliException e) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28592       };
28593     } catch (...) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28596       };
28597     }
28598   }
28599
28600   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28606   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28607   Dali::FrameBufferImage arg2 ;
28608   Dali::FrameBufferImage *argp2 ;
28609
28610   arg1 = (Dali::RenderTask *)jarg1;
28611   argp2 = (Dali::FrameBufferImage *)jarg2;
28612   if (!argp2) {
28613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28614     return ;
28615   }
28616   arg2 = *argp2;
28617   {
28618     try {
28619       (arg1)->SetTargetFrameBuffer(arg2);
28620     } catch (std::out_of_range& e) {
28621       {
28622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (std::exception& e) {
28625       {
28626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28627       };
28628     } catch (Dali::DaliException e) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28631       };
28632     } catch (...) {
28633       {
28634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28635       };
28636     }
28637   }
28638
28639 }
28640
28641
28642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28643   void * jresult ;
28644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28645   Dali::FrameBufferImage result;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   {
28649     try {
28650       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28658       };
28659     } catch (Dali::DaliException e) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28662       };
28663     } catch (...) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28666       };
28667     }
28668   }
28669
28670   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28676   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28677   Dali::FrameBuffer arg2 ;
28678   Dali::FrameBuffer *argp2 ;
28679
28680   arg1 = (Dali::RenderTask *)jarg1;
28681   argp2 = (Dali::FrameBuffer *)jarg2;
28682   if (!argp2) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28684     return ;
28685   }
28686   arg2 = *argp2;
28687   {
28688     try {
28689       (arg1)->SetFrameBuffer(arg2);
28690     } catch (std::out_of_range& e) {
28691       {
28692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (std::exception& e) {
28695       {
28696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28697       };
28698     } catch (Dali::DaliException e) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28701       };
28702     } catch (...) {
28703       {
28704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28705       };
28706     }
28707   }
28708
28709 }
28710
28711
28712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28713   void * jresult ;
28714   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28715   Dali::FrameBuffer result;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   {
28719     try {
28720       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28721     } catch (std::out_of_range& e) {
28722       {
28723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (std::exception& e) {
28726       {
28727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28728       };
28729     } catch (Dali::DaliException e) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28732       };
28733     } catch (...) {
28734       {
28735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28736       };
28737     }
28738   }
28739
28740   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28746   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28747   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28748
28749   arg1 = (Dali::RenderTask *)jarg1;
28750   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28751   {
28752     try {
28753       (arg1)->SetScreenToFrameBufferFunction(arg2);
28754     } catch (std::out_of_range& e) {
28755       {
28756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28757       };
28758     } catch (std::exception& e) {
28759       {
28760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28761       };
28762     } catch (Dali::DaliException e) {
28763       {
28764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28765       };
28766     } catch (...) {
28767       {
28768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28769       };
28770     }
28771   }
28772
28773 }
28774
28775
28776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28777   void * jresult ;
28778   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28779   Dali::RenderTask::ScreenToFrameBufferFunction result;
28780
28781   arg1 = (Dali::RenderTask *)jarg1;
28782   {
28783     try {
28784       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28785     } catch (std::out_of_range& e) {
28786       {
28787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28788       };
28789     } catch (std::exception& e) {
28790       {
28791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28792       };
28793     } catch (Dali::DaliException e) {
28794       {
28795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28796       };
28797     } catch (...) {
28798       {
28799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28800       };
28801     }
28802   }
28803
28804   jresult = (void *)result;
28805   return jresult;
28806 }
28807
28808
28809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28810   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28811   Dali::Actor arg2 ;
28812   Dali::Actor *argp2 ;
28813
28814   arg1 = (Dali::RenderTask *)jarg1;
28815   argp2 = (Dali::Actor *)jarg2;
28816   if (!argp2) {
28817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28818     return ;
28819   }
28820   arg2 = *argp2;
28821   {
28822     try {
28823       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28824     } catch (std::out_of_range& e) {
28825       {
28826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28827       };
28828     } catch (std::exception& e) {
28829       {
28830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28831       };
28832     } catch (Dali::DaliException e) {
28833       {
28834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28835       };
28836     } catch (...) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28839       };
28840     }
28841   }
28842
28843 }
28844
28845
28846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28847   void * jresult ;
28848   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28849   Dali::Actor result;
28850
28851   arg1 = (Dali::RenderTask *)jarg1;
28852   {
28853     try {
28854       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28855     } catch (std::out_of_range& e) {
28856       {
28857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28858       };
28859     } catch (std::exception& e) {
28860       {
28861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28862       };
28863     } catch (Dali::DaliException e) {
28864       {
28865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28866       };
28867     } catch (...) {
28868       {
28869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28870       };
28871     }
28872   }
28873
28874   jresult = new Dali::Actor((const Dali::Actor &)result);
28875   return jresult;
28876 }
28877
28878
28879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28880   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28881   Dali::Vector2 arg2 ;
28882   Dali::Vector2 *argp2 ;
28883
28884   arg1 = (Dali::RenderTask *)jarg1;
28885   argp2 = (Dali::Vector2 *)jarg2;
28886   if (!argp2) {
28887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28888     return ;
28889   }
28890   arg2 = *argp2;
28891   {
28892     try {
28893       (arg1)->SetViewportPosition(arg2);
28894     } catch (std::out_of_range& e) {
28895       {
28896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (std::exception& e) {
28899       {
28900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28901       };
28902     } catch (Dali::DaliException e) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28905       };
28906     } catch (...) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28909       };
28910     }
28911   }
28912
28913 }
28914
28915
28916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28917   void * jresult ;
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   Dali::Vector2 result;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   {
28923     try {
28924       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28925     } catch (std::out_of_range& e) {
28926       {
28927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (std::exception& e) {
28930       {
28931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28932       };
28933     } catch (Dali::DaliException e) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28936       };
28937     } catch (...) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28940       };
28941     }
28942   }
28943
28944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28945   return jresult;
28946 }
28947
28948
28949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   Dali::Vector2 arg2 ;
28952   Dali::Vector2 *argp2 ;
28953
28954   arg1 = (Dali::RenderTask *)jarg1;
28955   argp2 = (Dali::Vector2 *)jarg2;
28956   if (!argp2) {
28957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28958     return ;
28959   }
28960   arg2 = *argp2;
28961   {
28962     try {
28963       (arg1)->SetViewportSize(arg2);
28964     } catch (std::out_of_range& e) {
28965       {
28966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28967       };
28968     } catch (std::exception& e) {
28969       {
28970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28971       };
28972     } catch (Dali::DaliException e) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28975       };
28976     } catch (...) {
28977       {
28978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28979       };
28980     }
28981   }
28982
28983 }
28984
28985
28986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28987   void * jresult ;
28988   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28989   Dali::Vector2 result;
28990
28991   arg1 = (Dali::RenderTask *)jarg1;
28992   {
28993     try {
28994       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28995     } catch (std::out_of_range& e) {
28996       {
28997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (std::exception& e) {
29000       {
29001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29002       };
29003     } catch (Dali::DaliException e) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29006       };
29007     } catch (...) {
29008       {
29009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29010       };
29011     }
29012   }
29013
29014   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29015   return jresult;
29016 }
29017
29018
29019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29020   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29021   Dali::Viewport arg2 ;
29022   Dali::Viewport *argp2 ;
29023
29024   arg1 = (Dali::RenderTask *)jarg1;
29025   argp2 = (Dali::Viewport *)jarg2;
29026   if (!argp2) {
29027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29028     return ;
29029   }
29030   arg2 = *argp2;
29031   {
29032     try {
29033       (arg1)->SetViewport(arg2);
29034     } catch (std::out_of_range& e) {
29035       {
29036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29037       };
29038     } catch (std::exception& e) {
29039       {
29040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29041       };
29042     } catch (Dali::DaliException e) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29045       };
29046     } catch (...) {
29047       {
29048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29049       };
29050     }
29051   }
29052
29053 }
29054
29055
29056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29057   void * jresult ;
29058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29059   Dali::Viewport result;
29060
29061   arg1 = (Dali::RenderTask *)jarg1;
29062   {
29063     try {
29064       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29065     } catch (std::out_of_range& e) {
29066       {
29067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (std::exception& e) {
29070       {
29071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29072       };
29073     } catch (Dali::DaliException e) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29076       };
29077     } catch (...) {
29078       {
29079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29080       };
29081     }
29082   }
29083
29084   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29085   return jresult;
29086 }
29087
29088
29089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29090   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29091   Dali::Vector4 *arg2 = 0 ;
29092
29093   arg1 = (Dali::RenderTask *)jarg1;
29094   arg2 = (Dali::Vector4 *)jarg2;
29095   if (!arg2) {
29096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29097     return ;
29098   }
29099   {
29100     try {
29101       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29102     } catch (std::out_of_range& e) {
29103       {
29104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29105       };
29106     } catch (std::exception& e) {
29107       {
29108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29109       };
29110     } catch (Dali::DaliException e) {
29111       {
29112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29113       };
29114     } catch (...) {
29115       {
29116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29117       };
29118     }
29119   }
29120
29121 }
29122
29123
29124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29125   void * jresult ;
29126   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29127   Dali::Vector4 result;
29128
29129   arg1 = (Dali::RenderTask *)jarg1;
29130   {
29131     try {
29132       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29133     } catch (std::out_of_range& e) {
29134       {
29135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (std::exception& e) {
29138       {
29139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29140       };
29141     } catch (Dali::DaliException e) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29144       };
29145     } catch (...) {
29146       {
29147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29148       };
29149     }
29150   }
29151
29152   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29153   return jresult;
29154 }
29155
29156
29157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29159   bool arg2 ;
29160
29161   arg1 = (Dali::RenderTask *)jarg1;
29162   arg2 = jarg2 ? true : false;
29163   {
29164     try {
29165       (arg1)->SetClearEnabled(arg2);
29166     } catch (std::out_of_range& e) {
29167       {
29168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29169       };
29170     } catch (std::exception& e) {
29171       {
29172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29173       };
29174     } catch (Dali::DaliException e) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29177       };
29178     } catch (...) {
29179       {
29180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29181       };
29182     }
29183   }
29184
29185 }
29186
29187
29188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29189   unsigned int jresult ;
29190   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29191   bool result;
29192
29193   arg1 = (Dali::RenderTask *)jarg1;
29194   {
29195     try {
29196       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29197     } catch (std::out_of_range& e) {
29198       {
29199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (std::exception& e) {
29202       {
29203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29204       };
29205     } catch (Dali::DaliException e) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29208       };
29209     } catch (...) {
29210       {
29211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29212       };
29213     }
29214   }
29215
29216   jresult = result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29222   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29223   bool arg2 ;
29224
29225   arg1 = (Dali::RenderTask *)jarg1;
29226   arg2 = jarg2 ? true : false;
29227   {
29228     try {
29229       (arg1)->SetCullMode(arg2);
29230     } catch (std::out_of_range& e) {
29231       {
29232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29233       };
29234     } catch (std::exception& e) {
29235       {
29236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29237       };
29238     } catch (Dali::DaliException e) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29241       };
29242     } catch (...) {
29243       {
29244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29245       };
29246     }
29247   }
29248
29249 }
29250
29251
29252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29253   unsigned int jresult ;
29254   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29255   bool result;
29256
29257   arg1 = (Dali::RenderTask *)jarg1;
29258   {
29259     try {
29260       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29261     } catch (std::out_of_range& e) {
29262       {
29263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (std::exception& e) {
29266       {
29267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29268       };
29269     } catch (Dali::DaliException e) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29272       };
29273     } catch (...) {
29274       {
29275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29276       };
29277     }
29278   }
29279
29280   jresult = result;
29281   return jresult;
29282 }
29283
29284
29285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29287   unsigned int arg2 ;
29288
29289   arg1 = (Dali::RenderTask *)jarg1;
29290   arg2 = (unsigned int)jarg2;
29291   {
29292     try {
29293       (arg1)->SetRefreshRate(arg2);
29294     } catch (std::out_of_range& e) {
29295       {
29296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (std::exception& e) {
29299       {
29300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29301       };
29302     } catch (Dali::DaliException e) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29309       };
29310     }
29311   }
29312
29313 }
29314
29315
29316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29317   unsigned int jresult ;
29318   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29319   unsigned int result;
29320
29321   arg1 = (Dali::RenderTask *)jarg1;
29322   {
29323     try {
29324       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29325     } catch (std::out_of_range& e) {
29326       {
29327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (std::exception& e) {
29330       {
29331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (Dali::DaliException e) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29340       };
29341     }
29342   }
29343
29344   jresult = result;
29345   return jresult;
29346 }
29347
29348
29349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29350   unsigned int jresult ;
29351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29352   Dali::Vector3 *arg2 = 0 ;
29353   float *arg3 = 0 ;
29354   float *arg4 = 0 ;
29355   bool result;
29356
29357   arg1 = (Dali::RenderTask *)jarg1;
29358   arg2 = (Dali::Vector3 *)jarg2;
29359   if (!arg2) {
29360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29361     return 0;
29362   }
29363   arg3 = (float *)jarg3;
29364   arg4 = (float *)jarg4;
29365   {
29366     try {
29367       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29368     } catch (std::out_of_range& e) {
29369       {
29370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (std::exception& e) {
29373       {
29374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29375       };
29376     } catch (Dali::DaliException e) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29379       };
29380     } catch (...) {
29381       {
29382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29383       };
29384     }
29385   }
29386
29387   jresult = result;
29388   return jresult;
29389 }
29390
29391
29392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29393   unsigned int jresult ;
29394   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29395   Dali::Actor arg2 ;
29396   float arg3 ;
29397   float arg4 ;
29398   float *arg5 = 0 ;
29399   float *arg6 = 0 ;
29400   Dali::Actor *argp2 ;
29401   bool result;
29402
29403   arg1 = (Dali::RenderTask *)jarg1;
29404   argp2 = (Dali::Actor *)jarg2;
29405   if (!argp2) {
29406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29407     return 0;
29408   }
29409   arg2 = *argp2;
29410   arg3 = (float)jarg3;
29411   arg4 = (float)jarg4;
29412   arg5 = (float *)jarg5;
29413   arg6 = (float *)jarg6;
29414   {
29415     try {
29416       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29417     } catch (std::out_of_range& e) {
29418       {
29419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (std::exception& e) {
29422       {
29423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (Dali::DaliException e) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29428       };
29429     } catch (...) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29432       };
29433     }
29434   }
29435
29436   jresult = result;
29437   return jresult;
29438 }
29439
29440
29441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29442   void * jresult ;
29443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29444   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29445
29446   arg1 = (Dali::RenderTask *)jarg1;
29447   {
29448     try {
29449       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29450     } catch (std::out_of_range& e) {
29451       {
29452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (std::exception& e) {
29455       {
29456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (Dali::DaliException e) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29461       };
29462     } catch (...) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29465       };
29466     }
29467   }
29468
29469   jresult = (void *)result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29475   void * jresult ;
29476   int arg1 ;
29477   Dali::TouchPoint::State arg2 ;
29478   float arg3 ;
29479   float arg4 ;
29480   Dali::TouchPoint *result = 0 ;
29481
29482   arg1 = (int)jarg1;
29483   arg2 = (Dali::TouchPoint::State)jarg2;
29484   arg3 = (float)jarg3;
29485   arg4 = (float)jarg4;
29486   {
29487     try {
29488       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29489     } catch (std::out_of_range& e) {
29490       {
29491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (std::exception& e) {
29494       {
29495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (Dali::DaliException e) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29500       };
29501     } catch (...) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29504       };
29505     }
29506   }
29507
29508   jresult = (void *)result;
29509   return jresult;
29510 }
29511
29512
29513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29514   void * jresult ;
29515   int arg1 ;
29516   Dali::TouchPoint::State arg2 ;
29517   float arg3 ;
29518   float arg4 ;
29519   float arg5 ;
29520   float arg6 ;
29521   Dali::TouchPoint *result = 0 ;
29522
29523   arg1 = (int)jarg1;
29524   arg2 = (Dali::TouchPoint::State)jarg2;
29525   arg3 = (float)jarg3;
29526   arg4 = (float)jarg4;
29527   arg5 = (float)jarg5;
29528   arg6 = (float)jarg6;
29529   {
29530     try {
29531       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29532     } catch (std::out_of_range& e) {
29533       {
29534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (std::exception& e) {
29537       {
29538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (Dali::DaliException e) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29543       };
29544     } catch (...) {
29545       {
29546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29547       };
29548     }
29549   }
29550
29551   jresult = (void *)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29557   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29558
29559   arg1 = (Dali::TouchPoint *)jarg1;
29560   {
29561     try {
29562       delete arg1;
29563     } catch (std::out_of_range& e) {
29564       {
29565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29566       };
29567     } catch (std::exception& e) {
29568       {
29569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29570       };
29571     } catch (Dali::DaliException e) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29574       };
29575     } catch (...) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29578       };
29579     }
29580   }
29581
29582 }
29583
29584
29585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29586   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29587   int arg2 ;
29588
29589   arg1 = (Dali::TouchPoint *)jarg1;
29590   arg2 = (int)jarg2;
29591   if (arg1) (arg1)->deviceId = arg2;
29592 }
29593
29594
29595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29596   int jresult ;
29597   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29598   int result;
29599
29600   arg1 = (Dali::TouchPoint *)jarg1;
29601   result = (int) ((arg1)->deviceId);
29602   jresult = result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29608   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29609   Dali::TouchPoint::State arg2 ;
29610
29611   arg1 = (Dali::TouchPoint *)jarg1;
29612   arg2 = (Dali::TouchPoint::State)jarg2;
29613   if (arg1) (arg1)->state = arg2;
29614 }
29615
29616
29617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29618   int jresult ;
29619   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29620   Dali::TouchPoint::State result;
29621
29622   arg1 = (Dali::TouchPoint *)jarg1;
29623   result = (Dali::TouchPoint::State) ((arg1)->state);
29624   jresult = (int)result;
29625   return jresult;
29626 }
29627
29628
29629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29630   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29631   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29632
29633   arg1 = (Dali::TouchPoint *)jarg1;
29634   arg2 = (Dali::Actor *)jarg2;
29635   if (arg1) (arg1)->hitActor = *arg2;
29636 }
29637
29638
29639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29640   void * jresult ;
29641   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29642   Dali::Actor *result = 0 ;
29643
29644   arg1 = (Dali::TouchPoint *)jarg1;
29645   result = (Dali::Actor *)& ((arg1)->hitActor);
29646   jresult = (void *)result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29652   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29653   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29654
29655   arg1 = (Dali::TouchPoint *)jarg1;
29656   arg2 = (Dali::Vector2 *)jarg2;
29657   if (arg1) (arg1)->local = *arg2;
29658 }
29659
29660
29661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29662   void * jresult ;
29663   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29664   Dali::Vector2 *result = 0 ;
29665
29666   arg1 = (Dali::TouchPoint *)jarg1;
29667   result = (Dali::Vector2 *)& ((arg1)->local);
29668   jresult = (void *)result;
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29674   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29675   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29676
29677   arg1 = (Dali::TouchPoint *)jarg1;
29678   arg2 = (Dali::Vector2 *)jarg2;
29679   if (arg1) (arg1)->screen = *arg2;
29680 }
29681
29682
29683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29684   void * jresult ;
29685   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29686   Dali::Vector2 *result = 0 ;
29687
29688   arg1 = (Dali::TouchPoint *)jarg1;
29689   result = (Dali::Vector2 *)& ((arg1)->screen);
29690   jresult = (void *)result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29696   void * jresult ;
29697   Dali::TouchData *result = 0 ;
29698
29699   {
29700     try {
29701       result = (Dali::TouchData *)new Dali::TouchData();
29702     } catch (std::out_of_range& e) {
29703       {
29704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (std::exception& e) {
29707       {
29708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (Dali::DaliException e) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29713       };
29714     } catch (...) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29717       };
29718     }
29719   }
29720
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29727   void * jresult ;
29728   Dali::TouchData *arg1 = 0 ;
29729   Dali::TouchData *result = 0 ;
29730
29731   arg1 = (Dali::TouchData *)jarg1;
29732   if (!arg1) {
29733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29734     return 0;
29735   }
29736   {
29737     try {
29738       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29746       };
29747     } catch (Dali::DaliException e) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29754       };
29755     }
29756   }
29757
29758   jresult = (void *)result;
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765
29766   arg1 = (Dali::TouchData *)jarg1;
29767   {
29768     try {
29769       delete arg1;
29770     } catch (std::out_of_range& e) {
29771       {
29772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (std::exception& e) {
29775       {
29776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29777       };
29778     } catch (Dali::DaliException e) {
29779       {
29780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29781       };
29782     } catch (...) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29785       };
29786     }
29787   }
29788
29789 }
29790
29791
29792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29793   void * jresult ;
29794   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29795   Dali::TouchData *arg2 = 0 ;
29796   Dali::TouchData *result = 0 ;
29797
29798   arg1 = (Dali::TouchData *)jarg1;
29799   arg2 = (Dali::TouchData *)jarg2;
29800   if (!arg2) {
29801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29802     return 0;
29803   }
29804   {
29805     try {
29806       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29807     } catch (std::out_of_range& e) {
29808       {
29809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29810       };
29811     } catch (std::exception& e) {
29812       {
29813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (Dali::DaliException e) {
29816       {
29817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29818       };
29819     } catch (...) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29822       };
29823     }
29824   }
29825
29826   jresult = (void *)result;
29827   return jresult;
29828 }
29829
29830
29831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29832   unsigned long jresult ;
29833   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29834   unsigned long result;
29835
29836   arg1 = (Dali::TouchData *)jarg1;
29837   {
29838     try {
29839       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29840     } catch (std::out_of_range& e) {
29841       {
29842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29843       };
29844     } catch (std::exception& e) {
29845       {
29846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (Dali::DaliException e) {
29849       {
29850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29851       };
29852     } catch (...) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29855       };
29856     }
29857   }
29858
29859   jresult = (unsigned long)result;
29860   return jresult;
29861 }
29862
29863
29864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29865   unsigned long jresult ;
29866   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29867   std::size_t result;
29868
29869   arg1 = (Dali::TouchData *)jarg1;
29870   {
29871     try {
29872       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29873     } catch (std::out_of_range& e) {
29874       {
29875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (std::exception& e) {
29878       {
29879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29880       };
29881     } catch (Dali::DaliException e) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29884       };
29885     } catch (...) {
29886       {
29887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29888       };
29889     }
29890   }
29891
29892   jresult = (unsigned long)result;
29893   return jresult;
29894 }
29895
29896
29897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29898   int jresult ;
29899   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29900   std::size_t arg2 ;
29901   int32_t result;
29902
29903   arg1 = (Dali::TouchData *)jarg1;
29904   arg2 = (std::size_t)jarg2;
29905   {
29906     try {
29907       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29908     } catch (std::out_of_range& e) {
29909       {
29910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (std::exception& e) {
29913       {
29914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29915       };
29916     } catch (Dali::DaliException e) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29919       };
29920     } catch (...) {
29921       {
29922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29923       };
29924     }
29925   }
29926
29927   jresult = result;
29928   return jresult;
29929 }
29930
29931
29932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29933   int jresult ;
29934   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29935   std::size_t arg2 ;
29936   Dali::PointState::Type result;
29937
29938   arg1 = (Dali::TouchData *)jarg1;
29939   arg2 = (std::size_t)jarg2;
29940   {
29941     try {
29942       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29943     } catch (std::out_of_range& e) {
29944       {
29945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29946       };
29947     } catch (std::exception& e) {
29948       {
29949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (Dali::DaliException e) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961
29962   jresult = (int)result;
29963   return jresult;
29964 }
29965
29966
29967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29968   void * jresult ;
29969   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29970   std::size_t arg2 ;
29971   Dali::Actor result;
29972
29973   arg1 = (Dali::TouchData *)jarg1;
29974   arg2 = (std::size_t)jarg2;
29975   {
29976     try {
29977       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29978     } catch (std::out_of_range& e) {
29979       {
29980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (std::exception& e) {
29983       {
29984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29985       };
29986     } catch (Dali::DaliException e) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29989       };
29990     } catch (...) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29993       };
29994     }
29995   }
29996
29997   jresult = new Dali::Actor((const Dali::Actor &)result);
29998   return jresult;
29999 }
30000
30001
30002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30003   void * jresult ;
30004   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30005   std::size_t arg2 ;
30006   Dali::Vector2 *result = 0 ;
30007
30008   arg1 = (Dali::TouchData *)jarg1;
30009   arg2 = (std::size_t)jarg2;
30010   {
30011     try {
30012       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30013     } catch (std::out_of_range& e) {
30014       {
30015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30016       };
30017     } catch (std::exception& e) {
30018       {
30019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30020       };
30021     } catch (Dali::DaliException e) {
30022       {
30023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30024       };
30025     } catch (...) {
30026       {
30027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30028       };
30029     }
30030   }
30031
30032   jresult = (void *)result;
30033   return jresult;
30034 }
30035
30036
30037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30038   void * jresult ;
30039   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30040   std::size_t arg2 ;
30041   Dali::Vector2 *result = 0 ;
30042
30043   arg1 = (Dali::TouchData *)jarg1;
30044   arg2 = (std::size_t)jarg2;
30045   {
30046     try {
30047       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30048     } catch (std::out_of_range& e) {
30049       {
30050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30051       };
30052     } catch (std::exception& e) {
30053       {
30054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30055       };
30056     } catch (Dali::DaliException e) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30059       };
30060     } catch (...) {
30061       {
30062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30063       };
30064     }
30065   }
30066
30067   jresult = (void *)result;
30068   return jresult;
30069 }
30070
30071
30072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30073   float jresult ;
30074   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30075   std::size_t arg2 ;
30076   float result;
30077
30078   arg1 = (Dali::TouchData *)jarg1;
30079   arg2 = (std::size_t)jarg2;
30080   {
30081     try {
30082       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30083     } catch (std::out_of_range& e) {
30084       {
30085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (std::exception& e) {
30088       {
30089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30090       };
30091     } catch (Dali::DaliException e) {
30092       {
30093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30094       };
30095     } catch (...) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30098       };
30099     }
30100   }
30101
30102   jresult = result;
30103   return jresult;
30104 }
30105
30106
30107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30108   void * jresult ;
30109   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30110   std::size_t arg2 ;
30111   Dali::Vector2 *result = 0 ;
30112
30113   arg1 = (Dali::TouchData *)jarg1;
30114   arg2 = (std::size_t)jarg2;
30115   {
30116     try {
30117       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30118     } catch (std::out_of_range& e) {
30119       {
30120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30121       };
30122     } catch (std::exception& e) {
30123       {
30124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30125       };
30126     } catch (Dali::DaliException e) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30129       };
30130     } catch (...) {
30131       {
30132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30133       };
30134     }
30135   }
30136
30137   jresult = (void *)result;
30138   return jresult;
30139 }
30140
30141
30142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30143   float jresult ;
30144   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30145   std::size_t arg2 ;
30146   float result;
30147
30148   arg1 = (Dali::TouchData *)jarg1;
30149   arg2 = (std::size_t)jarg2;
30150   {
30151     try {
30152       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30153     } catch (std::out_of_range& e) {
30154       {
30155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (std::exception& e) {
30158       {
30159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30160       };
30161     } catch (Dali::DaliException e) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30164       };
30165     } catch (...) {
30166       {
30167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30168       };
30169     }
30170   }
30171
30172   jresult = result;
30173   return jresult;
30174 }
30175
30176
30177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30178   void * jresult ;
30179   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30180   std::size_t arg2 ;
30181   Dali::Degree result;
30182
30183   arg1 = (Dali::TouchData *)jarg1;
30184   arg2 = (std::size_t)jarg2;
30185   {
30186     try {
30187       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30188     } catch (std::out_of_range& e) {
30189       {
30190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30191       };
30192     } catch (std::exception& e) {
30193       {
30194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (Dali::DaliException e) {
30197       {
30198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30199       };
30200     } catch (...) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30203       };
30204     }
30205   }
30206
30207   jresult = new Dali::Degree((const Dali::Degree &)result);
30208   return jresult;
30209 }
30210
30211
30212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30213   int jresult ;
30214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30215   std::size_t arg2 ;
30216   Dali::MouseButton::Type result;
30217
30218   arg1 = (Dali::TouchData *)jarg1;
30219   arg2 = (std::size_t)jarg2;
30220   {
30221     try {
30222       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30230       };
30231     } catch (Dali::DaliException e) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30234       };
30235     } catch (...) {
30236       {
30237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30238       };
30239     }
30240   }
30241
30242   jresult = static_cast< int >(result);
30243   return jresult;
30244 }
30245
30246
30247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30248   void * jresult ;
30249   Dali::GestureDetector *result = 0 ;
30250
30251   {
30252     try {
30253       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30254     } catch (std::out_of_range& e) {
30255       {
30256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30257       };
30258     } catch (std::exception& e) {
30259       {
30260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30261       };
30262     } catch (Dali::DaliException e) {
30263       {
30264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30265       };
30266     } catch (...) {
30267       {
30268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30269       };
30270     }
30271   }
30272
30273   jresult = (void *)result;
30274   return jresult;
30275 }
30276
30277
30278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30279   void * jresult ;
30280   Dali::BaseHandle arg1 ;
30281   Dali::BaseHandle *argp1 ;
30282   Dali::GestureDetector result;
30283
30284   argp1 = (Dali::BaseHandle *)jarg1;
30285   if (!argp1) {
30286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30287     return 0;
30288   }
30289   arg1 = *argp1;
30290   {
30291     try {
30292       result = Dali::GestureDetector::DownCast(arg1);
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (Dali::DaliException e) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30304       };
30305     } catch (...) {
30306       {
30307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30308       };
30309     }
30310   }
30311
30312   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30313   return jresult;
30314 }
30315
30316
30317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30318   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30319
30320   arg1 = (Dali::GestureDetector *)jarg1;
30321   {
30322     try {
30323       delete arg1;
30324     } catch (std::out_of_range& e) {
30325       {
30326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (std::exception& e) {
30329       {
30330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30331       };
30332     } catch (Dali::DaliException e) {
30333       {
30334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30335       };
30336     } catch (...) {
30337       {
30338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30339       };
30340     }
30341   }
30342
30343 }
30344
30345
30346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30347   void * jresult ;
30348   Dali::GestureDetector *arg1 = 0 ;
30349   Dali::GestureDetector *result = 0 ;
30350
30351   arg1 = (Dali::GestureDetector *)jarg1;
30352   if (!arg1) {
30353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30354     return 0;
30355   }
30356   {
30357     try {
30358       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30359     } catch (std::out_of_range& e) {
30360       {
30361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30362       };
30363     } catch (std::exception& e) {
30364       {
30365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30366       };
30367     } catch (Dali::DaliException e) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30370       };
30371     } catch (...) {
30372       {
30373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30374       };
30375     }
30376   }
30377
30378   jresult = (void *)result;
30379   return jresult;
30380 }
30381
30382
30383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30384   void * jresult ;
30385   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30386   Dali::GestureDetector *arg2 = 0 ;
30387   Dali::GestureDetector *result = 0 ;
30388
30389   arg1 = (Dali::GestureDetector *)jarg1;
30390   arg2 = (Dali::GestureDetector *)jarg2;
30391   if (!arg2) {
30392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30393     return 0;
30394   }
30395   {
30396     try {
30397       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30398     } catch (std::out_of_range& e) {
30399       {
30400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30401       };
30402     } catch (std::exception& e) {
30403       {
30404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30405       };
30406     } catch (Dali::DaliException e) {
30407       {
30408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30409       };
30410     } catch (...) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30413       };
30414     }
30415   }
30416
30417   jresult = (void *)result;
30418   return jresult;
30419 }
30420
30421
30422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30423   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30424   Dali::Actor arg2 ;
30425   Dali::Actor *argp2 ;
30426
30427   arg1 = (Dali::GestureDetector *)jarg1;
30428   argp2 = (Dali::Actor *)jarg2;
30429   if (!argp2) {
30430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30431     return ;
30432   }
30433   arg2 = *argp2;
30434   {
30435     try {
30436       (arg1)->Attach(arg2);
30437     } catch (std::out_of_range& e) {
30438       {
30439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (std::exception& e) {
30442       {
30443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30444       };
30445     } catch (Dali::DaliException e) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30448       };
30449     } catch (...) {
30450       {
30451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30452       };
30453     }
30454   }
30455
30456 }
30457
30458
30459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30460   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30461   Dali::Actor arg2 ;
30462   Dali::Actor *argp2 ;
30463
30464   arg1 = (Dali::GestureDetector *)jarg1;
30465   argp2 = (Dali::Actor *)jarg2;
30466   if (!argp2) {
30467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30468     return ;
30469   }
30470   arg2 = *argp2;
30471   {
30472     try {
30473       (arg1)->Detach(arg2);
30474     } catch (std::out_of_range& e) {
30475       {
30476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (std::exception& e) {
30479       {
30480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30481       };
30482     } catch (Dali::DaliException e) {
30483       {
30484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30485       };
30486     } catch (...) {
30487       {
30488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30489       };
30490     }
30491   }
30492
30493 }
30494
30495
30496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30497   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30498
30499   arg1 = (Dali::GestureDetector *)jarg1;
30500   {
30501     try {
30502       (arg1)->DetachAll();
30503     } catch (std::out_of_range& e) {
30504       {
30505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30506       };
30507     } catch (std::exception& e) {
30508       {
30509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30510       };
30511     } catch (Dali::DaliException e) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30514       };
30515     } catch (...) {
30516       {
30517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30518       };
30519     }
30520   }
30521
30522 }
30523
30524
30525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30526   unsigned long jresult ;
30527   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30528   size_t result;
30529
30530   arg1 = (Dali::GestureDetector *)jarg1;
30531   {
30532     try {
30533       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (unsigned long)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30559   void * jresult ;
30560   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30561   size_t arg2 ;
30562   Dali::Actor result;
30563
30564   arg1 = (Dali::GestureDetector *)jarg1;
30565   arg2 = (size_t)jarg2;
30566   {
30567     try {
30568       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30569     } catch (std::out_of_range& e) {
30570       {
30571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (std::exception& e) {
30574       {
30575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30576       };
30577     } catch (Dali::DaliException e) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30584       };
30585     }
30586   }
30587
30588   jresult = new Dali::Actor((const Dali::Actor &)result);
30589   return jresult;
30590 }
30591
30592
30593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30594   void * jresult ;
30595   Dali::Gesture *arg1 = 0 ;
30596   Dali::Gesture *result = 0 ;
30597
30598   arg1 = (Dali::Gesture *)jarg1;
30599   if (!arg1) {
30600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30601     return 0;
30602   }
30603   {
30604     try {
30605       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30606     } catch (std::out_of_range& e) {
30607       {
30608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (std::exception& e) {
30611       {
30612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30613       };
30614     } catch (Dali::DaliException e) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30617       };
30618     } catch (...) {
30619       {
30620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30621       };
30622     }
30623   }
30624
30625   jresult = (void *)result;
30626   return jresult;
30627 }
30628
30629
30630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30631   void * jresult ;
30632   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30633   Dali::Gesture *arg2 = 0 ;
30634   Dali::Gesture *result = 0 ;
30635
30636   arg1 = (Dali::Gesture *)jarg1;
30637   arg2 = (Dali::Gesture *)jarg2;
30638   if (!arg2) {
30639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30640     return 0;
30641   }
30642   {
30643     try {
30644       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30645     } catch (std::out_of_range& e) {
30646       {
30647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30648       };
30649     } catch (std::exception& e) {
30650       {
30651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30652       };
30653     } catch (Dali::DaliException e) {
30654       {
30655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30656       };
30657     } catch (...) {
30658       {
30659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30660       };
30661     }
30662   }
30663
30664   jresult = (void *)result;
30665   return jresult;
30666 }
30667
30668
30669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30670   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30671
30672   arg1 = (Dali::Gesture *)jarg1;
30673   {
30674     try {
30675       delete arg1;
30676     } catch (std::out_of_range& e) {
30677       {
30678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30679       };
30680     } catch (std::exception& e) {
30681       {
30682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30683       };
30684     } catch (Dali::DaliException e) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30687       };
30688     } catch (...) {
30689       {
30690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30691       };
30692     }
30693   }
30694
30695 }
30696
30697
30698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30699   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30700   Dali::Gesture::Type arg2 ;
30701
30702   arg1 = (Dali::Gesture *)jarg1;
30703   arg2 = (Dali::Gesture::Type)jarg2;
30704   if (arg1) (arg1)->type = arg2;
30705 }
30706
30707
30708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30709   int jresult ;
30710   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30711   Dali::Gesture::Type result;
30712
30713   arg1 = (Dali::Gesture *)jarg1;
30714   result = (Dali::Gesture::Type) ((arg1)->type);
30715   jresult = (int)result;
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30721   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30722   Dali::Gesture::State arg2 ;
30723
30724   arg1 = (Dali::Gesture *)jarg1;
30725   arg2 = (Dali::Gesture::State)jarg2;
30726   if (arg1) (arg1)->state = arg2;
30727 }
30728
30729
30730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30731   int jresult ;
30732   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30733   Dali::Gesture::State result;
30734
30735   arg1 = (Dali::Gesture *)jarg1;
30736   result = (Dali::Gesture::State) ((arg1)->state);
30737   jresult = (int)result;
30738   return jresult;
30739 }
30740
30741
30742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30743   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30744   unsigned int arg2 ;
30745
30746   arg1 = (Dali::Gesture *)jarg1;
30747   arg2 = (unsigned int)jarg2;
30748   if (arg1) (arg1)->time = arg2;
30749 }
30750
30751
30752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30753   unsigned int jresult ;
30754   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30755   unsigned int result;
30756
30757   arg1 = (Dali::Gesture *)jarg1;
30758   result = (unsigned int) ((arg1)->time);
30759   jresult = result;
30760   return jresult;
30761 }
30762
30763
30764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30765   void * jresult ;
30766   Dali::HoverEvent *result = 0 ;
30767
30768   {
30769     try {
30770       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30771     } catch (std::out_of_range& e) {
30772       {
30773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (std::exception& e) {
30776       {
30777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30778       };
30779     } catch (Dali::DaliException e) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30782       };
30783     } catch (...) {
30784       {
30785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30786       };
30787     }
30788   }
30789
30790   jresult = (void *)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30796   void * jresult ;
30797   unsigned long arg1 ;
30798   Dali::HoverEvent *result = 0 ;
30799
30800   arg1 = (unsigned long)jarg1;
30801   {
30802     try {
30803       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (Dali::DaliException e) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30815       };
30816     } catch (...) {
30817       {
30818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30819       };
30820     }
30821   }
30822
30823   jresult = (void *)result;
30824   return jresult;
30825 }
30826
30827
30828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30829   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30830
30831   arg1 = (Dali::HoverEvent *)jarg1;
30832   {
30833     try {
30834       delete arg1;
30835     } catch (std::out_of_range& e) {
30836       {
30837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (std::exception& e) {
30840       {
30841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30842       };
30843     } catch (Dali::DaliException e) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30850       };
30851     }
30852   }
30853
30854 }
30855
30856
30857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30858   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30859   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30860
30861   arg1 = (Dali::HoverEvent *)jarg1;
30862   arg2 = (Dali::TouchPointContainer *)jarg2;
30863   if (arg1) (arg1)->points = *arg2;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30868   void * jresult ;
30869   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30870   Dali::TouchPointContainer *result = 0 ;
30871
30872   arg1 = (Dali::HoverEvent *)jarg1;
30873   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30880   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30881   unsigned long arg2 ;
30882
30883   arg1 = (Dali::HoverEvent *)jarg1;
30884   arg2 = (unsigned long)jarg2;
30885   if (arg1) (arg1)->time = arg2;
30886 }
30887
30888
30889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30890   unsigned long jresult ;
30891   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30892   unsigned long result;
30893
30894   arg1 = (Dali::HoverEvent *)jarg1;
30895   result = (unsigned long) ((arg1)->time);
30896   jresult = (unsigned long)result;
30897   return jresult;
30898 }
30899
30900
30901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30902   unsigned int jresult ;
30903   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30904   unsigned int result;
30905
30906   arg1 = (Dali::HoverEvent *)jarg1;
30907   {
30908     try {
30909       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30910     } catch (std::out_of_range& e) {
30911       {
30912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (std::exception& e) {
30915       {
30916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (Dali::DaliException e) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30921       };
30922     } catch (...) {
30923       {
30924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30925       };
30926     }
30927   }
30928
30929   jresult = result;
30930   return jresult;
30931 }
30932
30933
30934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30935   void * jresult ;
30936   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30937   unsigned int arg2 ;
30938   Dali::TouchPoint *result = 0 ;
30939
30940   arg1 = (Dali::HoverEvent *)jarg1;
30941   arg2 = (unsigned int)jarg2;
30942   {
30943     try {
30944       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30952       };
30953     } catch (Dali::DaliException e) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30956       };
30957     } catch (...) {
30958       {
30959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30960       };
30961     }
30962   }
30963
30964   jresult = (void *)result;
30965   return jresult;
30966 }
30967
30968
30969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30970   void * jresult ;
30971   Dali::KeyEvent *result = 0 ;
30972
30973   {
30974     try {
30975       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30983       };
30984     } catch (Dali::DaliException e) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30987       };
30988     } catch (...) {
30989       {
30990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30991       };
30992     }
30993   }
30994
30995   jresult = (void *)result;
30996   return jresult;
30997 }
30998
30999
31000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31001   void * jresult ;
31002   std::string *arg1 = 0 ;
31003   std::string *arg2 = 0 ;
31004   int arg3 ;
31005   int arg4 ;
31006   unsigned long arg5 ;
31007   Dali::KeyEvent::State *arg6 = 0 ;
31008   Dali::KeyEvent::State temp6 ;
31009   Dali::KeyEvent *result = 0 ;
31010
31011   if (!jarg1) {
31012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31013     return 0;
31014   }
31015   std::string arg1_str(jarg1);
31016   arg1 = &arg1_str;
31017   if (!jarg2) {
31018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31019     return 0;
31020   }
31021   std::string arg2_str(jarg2);
31022   arg2 = &arg2_str;
31023   arg3 = (int)jarg3;
31024   arg4 = (int)jarg4;
31025   arg5 = (unsigned long)jarg5;
31026   temp6 = (Dali::KeyEvent::State)jarg6;
31027   arg6 = &temp6;
31028   {
31029     try {
31030       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31031     } catch (std::out_of_range& e) {
31032       {
31033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (std::exception& e) {
31036       {
31037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (Dali::DaliException e) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31042       };
31043     } catch (...) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31046       };
31047     }
31048   }
31049
31050   jresult = (void *)result;
31051
31052   //argout typemap for const std::string&
31053
31054
31055   //argout typemap for const std::string&
31056
31057   return jresult;
31058 }
31059
31060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31061   void * jresult ;
31062   Dali::KeyEvent *arg1 = 0 ;
31063   Dali::KeyEvent *result = 0 ;
31064
31065   arg1 = (Dali::KeyEvent *)jarg1;
31066   if (!arg1) {
31067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31068     return 0;
31069   }
31070   {
31071     try {
31072       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = (void *)result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31098   void * jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   Dali::KeyEvent *arg2 = 0 ;
31101   Dali::KeyEvent *result = 0 ;
31102
31103   arg1 = (Dali::KeyEvent *)jarg1;
31104   arg2 = (Dali::KeyEvent *)jarg2;
31105   if (!arg2) {
31106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31107     return 0;
31108   }
31109   {
31110     try {
31111       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (Dali::DaliException e) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31123       };
31124     } catch (...) {
31125       {
31126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31127       };
31128     }
31129   }
31130
31131   jresult = (void *)result;
31132   return jresult;
31133 }
31134
31135
31136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31137   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31138
31139   arg1 = (Dali::KeyEvent *)jarg1;
31140   {
31141     try {
31142       delete arg1;
31143     } catch (std::out_of_range& e) {
31144       {
31145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (std::exception& e) {
31148       {
31149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31150       };
31151     } catch (Dali::DaliException e) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31154       };
31155     } catch (...) {
31156       {
31157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31158       };
31159     }
31160   }
31161
31162 }
31163
31164
31165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31166   unsigned int jresult ;
31167   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31168   bool result;
31169
31170   arg1 = (Dali::KeyEvent *)jarg1;
31171   {
31172     try {
31173       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31174     } catch (std::out_of_range& e) {
31175       {
31176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31177       };
31178     } catch (std::exception& e) {
31179       {
31180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31181       };
31182     } catch (Dali::DaliException e) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31185       };
31186     } catch (...) {
31187       {
31188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31189       };
31190     }
31191   }
31192
31193   jresult = result;
31194   return jresult;
31195 }
31196
31197
31198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31199   unsigned int jresult ;
31200   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31201   bool result;
31202
31203   arg1 = (Dali::KeyEvent *)jarg1;
31204   {
31205     try {
31206       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31207     } catch (std::out_of_range& e) {
31208       {
31209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (std::exception& e) {
31212       {
31213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (Dali::DaliException e) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31218       };
31219     } catch (...) {
31220       {
31221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31222       };
31223     }
31224   }
31225
31226   jresult = result;
31227   return jresult;
31228 }
31229
31230
31231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31232   unsigned int jresult ;
31233   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31234   bool result;
31235
31236   arg1 = (Dali::KeyEvent *)jarg1;
31237   {
31238     try {
31239       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31240     } catch (std::out_of_range& e) {
31241       {
31242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (std::exception& e) {
31245       {
31246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (Dali::DaliException e) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31251       };
31252     } catch (...) {
31253       {
31254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31255       };
31256     }
31257   }
31258
31259   jresult = result;
31260   return jresult;
31261 }
31262
31263
31264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31265   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31266   std::string *arg2 = 0 ;
31267
31268   arg1 = (Dali::KeyEvent *)jarg1;
31269   if (!jarg2) {
31270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31271     return ;
31272   }
31273   std::string arg2_str(jarg2);
31274   arg2 = &arg2_str;
31275   if (arg1) (arg1)->keyPressedName = *arg2;
31276
31277   //argout typemap for const std::string&
31278
31279 }
31280
31281
31282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31283   char * jresult ;
31284
31285   if( jarg1 == NULL )
31286   {
31287     jresult = SWIG_csharp_string_callback( "" );
31288   }
31289   else
31290   {
31291     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31292     std::string *result = 0;
31293
31294     arg1 = ( Dali::KeyEvent * )jarg1;
31295     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31296     jresult = SWIG_csharp_string_callback( result->c_str() );
31297   }
31298
31299   return jresult;
31300 }
31301
31302
31303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31304   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31305   std::string *arg2 = 0 ;
31306
31307   arg1 = (Dali::KeyEvent *)jarg1;
31308   if (!jarg2) {
31309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31310     return ;
31311   }
31312   std::string arg2_str(jarg2);
31313   arg2 = &arg2_str;
31314   if (arg1) (arg1)->keyPressed = *arg2;
31315
31316   //argout typemap for const std::string&
31317
31318 }
31319
31320
31321 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31322   char * jresult ;
31323   if( NULL == jarg1 )
31324   {
31325     jresult = SWIG_csharp_string_callback( "" );
31326   }
31327   else
31328   {
31329     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31330     std::string *result = 0;
31331
31332     arg1 = ( Dali::KeyEvent * )jarg1;
31333     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31334     jresult = SWIG_csharp_string_callback( result->c_str() );
31335   }
31336   return jresult;
31337 }
31338
31339
31340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31342   int arg2 ;
31343
31344   arg1 = (Dali::KeyEvent *)jarg1;
31345   arg2 = (int)jarg2;
31346   if (arg1) (arg1)->keyCode = arg2;
31347 }
31348
31349
31350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31351   int jresult ;
31352   if( NULL == jarg1 )
31353   {
31354     jresult = -1;
31355   }
31356   else
31357   {
31358     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31359     int result;
31360
31361     arg1 = ( Dali::KeyEvent * )jarg1;
31362     result = (int)( ( arg1 )->keyCode );
31363     jresult = result;
31364   }
31365   return jresult;
31366 }
31367
31368
31369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31371   int arg2 ;
31372
31373   arg1 = (Dali::KeyEvent *)jarg1;
31374   arg2 = (int)jarg2;
31375   if (arg1) (arg1)->keyModifier = arg2;
31376 }
31377
31378
31379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31380   int jresult ;
31381   if( jarg1 == NULL )
31382   {
31383     jresult = -1;
31384   }
31385   else
31386   {
31387     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31388     int result;
31389
31390     arg1 = ( Dali::KeyEvent * )jarg1;
31391     result = (int)( ( arg1 )->keyModifier );
31392     jresult = result;
31393   }
31394   return jresult;
31395 }
31396
31397
31398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31399   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31400   unsigned long arg2 ;
31401
31402   arg1 = (Dali::KeyEvent *)jarg1;
31403   arg2 = (unsigned long)jarg2;
31404   if (arg1) (arg1)->time = arg2;
31405 }
31406
31407
31408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31409   unsigned long jresult ;
31410   if( jarg1 == NULL )
31411   {
31412     jresult = 0;
31413   }
31414   else
31415   {
31416     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31417     unsigned long result;
31418
31419     arg1 = ( Dali::KeyEvent * )jarg1;
31420     result = (unsigned long)( ( arg1 )->time );
31421     jresult = (unsigned long)result;
31422   }
31423   return jresult;
31424 }
31425
31426
31427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31429   Dali::KeyEvent::State arg2 ;
31430
31431   arg1 = (Dali::KeyEvent *)jarg1;
31432   arg2 = (Dali::KeyEvent::State)jarg2;
31433   if (arg1) (arg1)->state = arg2;
31434 }
31435
31436
31437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31438   int jresult ;
31439   if( jarg1 == NULL )
31440   {
31441     jresult = -1;
31442   }
31443   else
31444   {
31445     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31446     Dali::KeyEvent::State result;
31447
31448     arg1 = ( Dali::KeyEvent * )jarg1;
31449     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31450     jresult = (int)result;
31451   }
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31457   void * jresult ;
31458   Dali::LongPressGestureDetector *result = 0 ;
31459
31460   {
31461     try {
31462       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = (void *)result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31488   void * jresult ;
31489   Dali::LongPressGestureDetector result;
31490
31491   {
31492     try {
31493       result = Dali::LongPressGestureDetector::New();
31494     } catch (std::out_of_range& e) {
31495       {
31496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (std::exception& e) {
31499       {
31500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (Dali::DaliException e) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31505       };
31506     } catch (...) {
31507       {
31508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31509       };
31510     }
31511   }
31512
31513   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31514   return jresult;
31515 }
31516
31517
31518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31519   void * jresult ;
31520   unsigned int arg1 ;
31521   Dali::LongPressGestureDetector result;
31522
31523   arg1 = (unsigned int)jarg1;
31524   {
31525     try {
31526       result = Dali::LongPressGestureDetector::New(arg1);
31527     } catch (std::out_of_range& e) {
31528       {
31529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31530       };
31531     } catch (std::exception& e) {
31532       {
31533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31534       };
31535     } catch (Dali::DaliException e) {
31536       {
31537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31542       };
31543     }
31544   }
31545
31546   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31547   return jresult;
31548 }
31549
31550
31551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31552   void * jresult ;
31553   unsigned int arg1 ;
31554   unsigned int arg2 ;
31555   Dali::LongPressGestureDetector result;
31556
31557   arg1 = (unsigned int)jarg1;
31558   arg2 = (unsigned int)jarg2;
31559   {
31560     try {
31561       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31562     } catch (std::out_of_range& e) {
31563       {
31564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (std::exception& e) {
31567       {
31568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31569       };
31570     } catch (Dali::DaliException e) {
31571       {
31572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31573       };
31574     } catch (...) {
31575       {
31576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31577       };
31578     }
31579   }
31580
31581   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31582   return jresult;
31583 }
31584
31585
31586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31587   void * jresult ;
31588   Dali::BaseHandle arg1 ;
31589   Dali::BaseHandle *argp1 ;
31590   Dali::LongPressGestureDetector result;
31591
31592   argp1 = (Dali::BaseHandle *)jarg1;
31593   if (!argp1) {
31594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31595     return 0;
31596   }
31597   arg1 = *argp1;
31598   {
31599     try {
31600       result = Dali::LongPressGestureDetector::DownCast(arg1);
31601     } catch (std::out_of_range& e) {
31602       {
31603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31604       };
31605     } catch (std::exception& e) {
31606       {
31607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31608       };
31609     } catch (Dali::DaliException e) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31612       };
31613     } catch (...) {
31614       {
31615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31616       };
31617     }
31618   }
31619
31620   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31621   return jresult;
31622 }
31623
31624
31625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31626   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31627
31628   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31629   {
31630     try {
31631       delete arg1;
31632     } catch (std::out_of_range& e) {
31633       {
31634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31635       };
31636     } catch (std::exception& e) {
31637       {
31638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31639       };
31640     } catch (Dali::DaliException e) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31643       };
31644     } catch (...) {
31645       {
31646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31647       };
31648     }
31649   }
31650
31651 }
31652
31653
31654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31655   void * jresult ;
31656   Dali::LongPressGestureDetector *arg1 = 0 ;
31657   Dali::LongPressGestureDetector *result = 0 ;
31658
31659   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31660   if (!arg1) {
31661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31662     return 0;
31663   }
31664   {
31665     try {
31666       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31674       };
31675     } catch (Dali::DaliException e) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31678       };
31679     } catch (...) {
31680       {
31681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31682       };
31683     }
31684   }
31685
31686   jresult = (void *)result;
31687   return jresult;
31688 }
31689
31690
31691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31692   void * jresult ;
31693   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31694   Dali::LongPressGestureDetector *arg2 = 0 ;
31695   Dali::LongPressGestureDetector *result = 0 ;
31696
31697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31698   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31699   if (!arg2) {
31700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31701     return 0;
31702   }
31703   {
31704     try {
31705       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (Dali::DaliException e) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31717       };
31718     } catch (...) {
31719       {
31720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31721       };
31722     }
31723   }
31724
31725   jresult = (void *)result;
31726   return jresult;
31727 }
31728
31729
31730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   unsigned int arg2 ;
31733
31734   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31735   arg2 = (unsigned int)jarg2;
31736   {
31737     try {
31738       (arg1)->SetTouchesRequired(arg2);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31754       };
31755     }
31756   }
31757
31758 }
31759
31760
31761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31762   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31763   unsigned int arg2 ;
31764   unsigned int arg3 ;
31765
31766   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31767   arg2 = (unsigned int)jarg2;
31768   arg3 = (unsigned int)jarg3;
31769   {
31770     try {
31771       (arg1)->SetTouchesRequired(arg2,arg3);
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31787       };
31788     }
31789   }
31790
31791 }
31792
31793
31794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31795   unsigned int jresult ;
31796   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31797   unsigned int result;
31798
31799   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31800   {
31801     try {
31802       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31803     } catch (std::out_of_range& e) {
31804       {
31805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (std::exception& e) {
31808       {
31809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (Dali::DaliException e) {
31812       {
31813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821
31822   jresult = result;
31823   return jresult;
31824 }
31825
31826
31827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31828   unsigned int jresult ;
31829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31830   unsigned int result;
31831
31832   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31833   {
31834     try {
31835       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31836     } catch (std::out_of_range& e) {
31837       {
31838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (std::exception& e) {
31841       {
31842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31843       };
31844     } catch (Dali::DaliException e) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31847       };
31848     } catch (...) {
31849       {
31850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31851       };
31852     }
31853   }
31854
31855   jresult = result;
31856   return jresult;
31857 }
31858
31859
31860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31861   void * jresult ;
31862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31863   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31864
31865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31866   {
31867     try {
31868       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31869     } catch (std::out_of_range& e) {
31870       {
31871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (std::exception& e) {
31874       {
31875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31876       };
31877     } catch (Dali::DaliException e) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31880       };
31881     } catch (...) {
31882       {
31883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31884       };
31885     }
31886   }
31887
31888   jresult = (void *)result;
31889   return jresult;
31890 }
31891
31892
31893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31894   void * jresult ;
31895   Dali::Gesture::State arg1 ;
31896   Dali::LongPressGesture *result = 0 ;
31897
31898   arg1 = (Dali::Gesture::State)jarg1;
31899   {
31900     try {
31901       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31902     } catch (std::out_of_range& e) {
31903       {
31904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31905       };
31906     } catch (std::exception& e) {
31907       {
31908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31909       };
31910     } catch (Dali::DaliException e) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31913       };
31914     } catch (...) {
31915       {
31916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31917       };
31918     }
31919   }
31920
31921   jresult = (void *)result;
31922   return jresult;
31923 }
31924
31925
31926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31927   void * jresult ;
31928   Dali::LongPressGesture *arg1 = 0 ;
31929   Dali::LongPressGesture *result = 0 ;
31930
31931   arg1 = (Dali::LongPressGesture *)jarg1;
31932   if (!arg1) {
31933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31934     return 0;
31935   }
31936   {
31937     try {
31938       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31939     } catch (std::out_of_range& e) {
31940       {
31941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (std::exception& e) {
31944       {
31945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31946       };
31947     } catch (Dali::DaliException e) {
31948       {
31949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31950       };
31951     } catch (...) {
31952       {
31953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31954       };
31955     }
31956   }
31957
31958   jresult = (void *)result;
31959   return jresult;
31960 }
31961
31962
31963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31964   void * jresult ;
31965   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31966   Dali::LongPressGesture *arg2 = 0 ;
31967   Dali::LongPressGesture *result = 0 ;
31968
31969   arg1 = (Dali::LongPressGesture *)jarg1;
31970   arg2 = (Dali::LongPressGesture *)jarg2;
31971   if (!arg2) {
31972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31973     return 0;
31974   }
31975   {
31976     try {
31977       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31978     } catch (std::out_of_range& e) {
31979       {
31980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (std::exception& e) {
31983       {
31984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31985       };
31986     } catch (Dali::DaliException e) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31989       };
31990     } catch (...) {
31991       {
31992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31993       };
31994     }
31995   }
31996
31997   jresult = (void *)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32003   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32004
32005   arg1 = (Dali::LongPressGesture *)jarg1;
32006   {
32007     try {
32008       delete arg1;
32009     } catch (std::out_of_range& e) {
32010       {
32011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (std::exception& e) {
32014       {
32015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32016       };
32017     } catch (Dali::DaliException e) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32020       };
32021     } catch (...) {
32022       {
32023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32024       };
32025     }
32026   }
32027
32028 }
32029
32030
32031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32032   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32033   unsigned int arg2 ;
32034
32035   arg1 = (Dali::LongPressGesture *)jarg1;
32036   arg2 = (unsigned int)jarg2;
32037   if (arg1) (arg1)->numberOfTouches = arg2;
32038 }
32039
32040
32041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32042   unsigned int jresult ;
32043   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32044   unsigned int result;
32045
32046   arg1 = (Dali::LongPressGesture *)jarg1;
32047   result = (unsigned int) ((arg1)->numberOfTouches);
32048   jresult = result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32054   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32055   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32056
32057   arg1 = (Dali::LongPressGesture *)jarg1;
32058   arg2 = (Dali::Vector2 *)jarg2;
32059   if (arg1) (arg1)->screenPoint = *arg2;
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32064   void * jresult ;
32065   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32066   Dali::Vector2 *result = 0 ;
32067
32068   arg1 = (Dali::LongPressGesture *)jarg1;
32069   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32070   jresult = (void *)result;
32071   return jresult;
32072 }
32073
32074
32075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32076   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32077   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32078
32079   arg1 = (Dali::LongPressGesture *)jarg1;
32080   arg2 = (Dali::Vector2 *)jarg2;
32081   if (arg1) (arg1)->localPoint = *arg2;
32082 }
32083
32084
32085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32086   void * jresult ;
32087   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32088   Dali::Vector2 *result = 0 ;
32089
32090   arg1 = (Dali::LongPressGesture *)jarg1;
32091   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32092   jresult = (void *)result;
32093   return jresult;
32094 }
32095
32096
32097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32098   void * jresult ;
32099   Dali::WheelEvent *result = 0 ;
32100
32101   {
32102     try {
32103       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32104     } catch (std::out_of_range& e) {
32105       {
32106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (std::exception& e) {
32109       {
32110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32111       };
32112     } catch (Dali::DaliException e) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32115       };
32116     } catch (...) {
32117       {
32118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32119       };
32120     }
32121   }
32122
32123   jresult = (void *)result;
32124   return jresult;
32125 }
32126
32127
32128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32129   void * jresult ;
32130   Dali::WheelEvent::Type arg1 ;
32131   int arg2 ;
32132   unsigned int arg3 ;
32133   Dali::Vector2 arg4 ;
32134   int arg5 ;
32135   unsigned int arg6 ;
32136   Dali::Vector2 *argp4 ;
32137   Dali::WheelEvent *result = 0 ;
32138
32139   arg1 = (Dali::WheelEvent::Type)jarg1;
32140   arg2 = (int)jarg2;
32141   arg3 = (unsigned int)jarg3;
32142   argp4 = (Dali::Vector2 *)jarg4;
32143   if (!argp4) {
32144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32145     return 0;
32146   }
32147   arg4 = *argp4;
32148   arg5 = (int)jarg5;
32149   arg6 = (unsigned int)jarg6;
32150   {
32151     try {
32152       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32153     } catch (std::out_of_range& e) {
32154       {
32155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (std::exception& e) {
32158       {
32159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32160       };
32161     } catch (Dali::DaliException e) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32168       };
32169     }
32170   }
32171
32172   jresult = (void *)result;
32173   return jresult;
32174 }
32175
32176
32177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32179
32180   arg1 = (Dali::WheelEvent *)jarg1;
32181   {
32182     try {
32183       delete arg1;
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32191       };
32192     } catch (Dali::DaliException e) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32195       };
32196     } catch (...) {
32197       {
32198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32199       };
32200     }
32201   }
32202
32203 }
32204
32205
32206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32207   unsigned int jresult ;
32208   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32209   bool result;
32210
32211   arg1 = (Dali::WheelEvent *)jarg1;
32212   {
32213     try {
32214       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32215     } catch (std::out_of_range& e) {
32216       {
32217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (std::exception& e) {
32220       {
32221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32222       };
32223     } catch (Dali::DaliException e) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32226       };
32227     } catch (...) {
32228       {
32229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32230       };
32231     }
32232   }
32233
32234   jresult = result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32240   unsigned int jresult ;
32241   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32242   bool result;
32243
32244   arg1 = (Dali::WheelEvent *)jarg1;
32245   {
32246     try {
32247       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32248     } catch (std::out_of_range& e) {
32249       {
32250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (std::exception& e) {
32253       {
32254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (Dali::DaliException e) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32259       };
32260     } catch (...) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32263       };
32264     }
32265   }
32266
32267   jresult = result;
32268   return jresult;
32269 }
32270
32271
32272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32273   unsigned int jresult ;
32274   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32275   bool result;
32276
32277   arg1 = (Dali::WheelEvent *)jarg1;
32278   {
32279     try {
32280       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32281     } catch (std::out_of_range& e) {
32282       {
32283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32284       };
32285     } catch (std::exception& e) {
32286       {
32287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32288       };
32289     } catch (Dali::DaliException e) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32292       };
32293     } catch (...) {
32294       {
32295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32296       };
32297     }
32298   }
32299
32300   jresult = result;
32301   return jresult;
32302 }
32303
32304
32305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32307   Dali::WheelEvent::Type arg2 ;
32308
32309   arg1 = (Dali::WheelEvent *)jarg1;
32310   arg2 = (Dali::WheelEvent::Type)jarg2;
32311   if (arg1) (arg1)->type = arg2;
32312 }
32313
32314
32315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32316   int jresult ;
32317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32318   Dali::WheelEvent::Type result;
32319
32320   arg1 = (Dali::WheelEvent *)jarg1;
32321   result = (Dali::WheelEvent::Type) ((arg1)->type);
32322   jresult = (int)result;
32323   return jresult;
32324 }
32325
32326
32327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32329   int arg2 ;
32330
32331   arg1 = (Dali::WheelEvent *)jarg1;
32332   arg2 = (int)jarg2;
32333   if (arg1) (arg1)->direction = arg2;
32334 }
32335
32336
32337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32338   int jresult ;
32339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32340   int result;
32341
32342   arg1 = (Dali::WheelEvent *)jarg1;
32343   result = (int) ((arg1)->direction);
32344   jresult = result;
32345   return jresult;
32346 }
32347
32348
32349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32351   unsigned int arg2 ;
32352
32353   arg1 = (Dali::WheelEvent *)jarg1;
32354   arg2 = (unsigned int)jarg2;
32355   if (arg1) (arg1)->modifiers = arg2;
32356 }
32357
32358
32359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32360   unsigned int jresult ;
32361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32362   unsigned int result;
32363
32364   arg1 = (Dali::WheelEvent *)jarg1;
32365   result = (unsigned int) ((arg1)->modifiers);
32366   jresult = result;
32367   return jresult;
32368 }
32369
32370
32371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32373   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32374
32375   arg1 = (Dali::WheelEvent *)jarg1;
32376   arg2 = (Dali::Vector2 *)jarg2;
32377   if (arg1) (arg1)->point = *arg2;
32378 }
32379
32380
32381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32382   void * jresult ;
32383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32384   Dali::Vector2 *result = 0 ;
32385
32386   arg1 = (Dali::WheelEvent *)jarg1;
32387   result = (Dali::Vector2 *)& ((arg1)->point);
32388   jresult = (void *)result;
32389   return jresult;
32390 }
32391
32392
32393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32395   int arg2 ;
32396
32397   arg1 = (Dali::WheelEvent *)jarg1;
32398   arg2 = (int)jarg2;
32399   if (arg1) (arg1)->z = arg2;
32400 }
32401
32402
32403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32404   int jresult ;
32405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32406   int result;
32407
32408   arg1 = (Dali::WheelEvent *)jarg1;
32409   result = (int) ((arg1)->z);
32410   jresult = result;
32411   return jresult;
32412 }
32413
32414
32415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32417   unsigned int arg2 ;
32418
32419   arg1 = (Dali::WheelEvent *)jarg1;
32420   arg2 = (unsigned int)jarg2;
32421   if (arg1) (arg1)->timeStamp = arg2;
32422 }
32423
32424
32425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32426   unsigned int jresult ;
32427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32428   unsigned int result;
32429
32430   arg1 = (Dali::WheelEvent *)jarg1;
32431   result = (unsigned int) ((arg1)->timeStamp);
32432   jresult = result;
32433   return jresult;
32434 }
32435
32436 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32437   char * jresult ;
32438   Dali::KeyEvent *arg1 = 0 ;
32439   std::string result;
32440
32441   arg1 = (Dali::KeyEvent *)jarg1;
32442   if (!arg1) {
32443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32444     return 0;
32445   }
32446   {
32447     try {
32448       result = arg1->GetDeviceName();
32449     } catch (std::out_of_range& e) {
32450       {
32451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (std::exception& e) {
32454       {
32455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32456       };
32457     } catch (Dali::DaliException e) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32460       };
32461     } catch (...) {
32462       {
32463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32464       };
32465     }
32466   }
32467
32468   jresult = SWIG_csharp_string_callback((&result)->c_str());
32469   return jresult;
32470 }
32471
32472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32473   int jresult ;
32474   Dali::KeyEvent *arg1 = 0 ;
32475   Dali::Device::Class::Type result;
32476
32477   arg1 = (Dali::KeyEvent *)jarg1;
32478   if (!arg1) {
32479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32480     return 0;
32481   }
32482   {
32483     try {
32484       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32485     } catch (std::out_of_range& e) {
32486       {
32487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (std::exception& e) {
32490       {
32491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32492       };
32493     } catch (Dali::DaliException e) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32496       };
32497     } catch (...) {
32498       {
32499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32500       };
32501     }
32502   }
32503
32504   jresult = (int)result;
32505   return jresult;
32506 }
32507
32508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32509   int jresult ;
32510   Dali::KeyEvent *arg1 = 0 ;
32511   Dali::Device::Subclass::Type result;
32512
32513   arg1 = (Dali::KeyEvent *)jarg1;
32514   if (!arg1) {
32515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32516     return 0;
32517   }
32518   {
32519     try {
32520       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32521     } catch (std::out_of_range& e) {
32522       {
32523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (std::exception& e) {
32526       {
32527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32528       };
32529     } catch (Dali::DaliException e) {
32530       {
32531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32532       };
32533     } catch (...) {
32534       {
32535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32536       };
32537     }
32538   }
32539
32540   jresult = (int)result;
32541   return jresult;
32542 }
32543
32544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32545   Dali::Actor arg1 ;
32546   Dali::Actor *argp1 ;
32547
32548   argp1 = (Dali::Actor *)jarg1;
32549   if (!argp1) {
32550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32551     return ;
32552   }
32553   arg1 = *argp1;
32554   {
32555     try {
32556       arg1.Raise();
32557     } catch (std::out_of_range& e) {
32558       {
32559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (std::exception& e) {
32562       {
32563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32564       };
32565     } catch (Dali::DaliException e) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32568       };
32569     } catch (...) {
32570       {
32571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32572       };
32573     }
32574   }
32575
32576 }
32577
32578
32579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32580   Dali::Actor arg1 ;
32581   Dali::Actor *argp1 ;
32582
32583   argp1 = (Dali::Actor *)jarg1;
32584   if (!argp1) {
32585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32586     return ;
32587   }
32588   arg1 = *argp1;
32589   {
32590     try {
32591       arg1.Lower();
32592     } catch (std::out_of_range& e) {
32593       {
32594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (std::exception& e) {
32597       {
32598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32599       };
32600     } catch (Dali::DaliException e) {
32601       {
32602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32603       };
32604     } catch (...) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32607       };
32608     }
32609   }
32610
32611 }
32612
32613
32614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32615   Dali::Actor arg1 ;
32616   Dali::Actor *argp1 ;
32617
32618   argp1 = (Dali::Actor *)jarg1;
32619   if (!argp1) {
32620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32621     return ;
32622   }
32623   arg1 = *argp1;
32624   {
32625     try {
32626       arg1.RaiseToTop();
32627     } catch (std::out_of_range& e) {
32628       {
32629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (std::exception& e) {
32632       {
32633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32634       };
32635     } catch (Dali::DaliException e) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32638       };
32639     } catch (...) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32642       };
32643     }
32644   }
32645
32646 }
32647
32648
32649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32650   Dali::Actor arg1 ;
32651   Dali::Actor *argp1 ;
32652
32653   argp1 = (Dali::Actor *)jarg1;
32654   if (!argp1) {
32655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32656     return ;
32657   }
32658   arg1 = *argp1;
32659   {
32660     try {
32661       arg1.LowerToBottom();
32662     } catch (std::out_of_range& e) {
32663       {
32664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (std::exception& e) {
32667       {
32668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32669       };
32670     } catch (Dali::DaliException e) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32673       };
32674     } catch (...) {
32675       {
32676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32677       };
32678     }
32679   }
32680
32681 }
32682
32683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32684   Dali::Actor arg1 ;
32685   Dali::Actor arg2 ;
32686   Dali::Actor *argp1 ;
32687   Dali::Actor *argp2 ;
32688
32689   argp1 = (Dali::Actor *)jarg1;
32690   if (!argp1) {
32691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32692     return ;
32693   }
32694   arg1 = *argp1;
32695   argp2 = (Dali::Actor *)jarg2;
32696   if (!argp2) {
32697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32698     return ;
32699   }
32700   arg2 = *argp2;
32701   {
32702     try {
32703       arg1.RaiseAbove(arg2);
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32711       };
32712     } catch (Dali::DaliException e) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32715       };
32716     } catch (...) {
32717       {
32718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32719       };
32720     }
32721   }
32722
32723 }
32724
32725
32726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32727   Dali::Actor arg1 ;
32728   Dali::Actor arg2 ;
32729   Dali::Actor *argp1 ;
32730   Dali::Actor *argp2 ;
32731
32732   argp1 = (Dali::Actor *)jarg1;
32733   if (!argp1) {
32734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32735     return ;
32736   }
32737   arg1 = *argp1;
32738   argp2 = (Dali::Actor *)jarg2;
32739   if (!argp2) {
32740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32741     return ;
32742   }
32743   arg2 = *argp2;
32744   {
32745     try {
32746       arg1.LowerBelow(arg2);
32747     } catch (std::out_of_range& e) {
32748       {
32749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32750       };
32751     } catch (std::exception& e) {
32752       {
32753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32754       };
32755     } catch (Dali::DaliException e) {
32756       {
32757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32758       };
32759     } catch (...) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32762       };
32763     }
32764   }
32765
32766 }
32767
32768
32769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32770   void * jresult ;
32771   Dali::Actor arg1 ;
32772   Dali::Actor *argp1 ;
32773   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32774
32775   argp1 = (Dali::Actor *)jarg1;
32776   if (!argp1) {
32777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32778     return 0;
32779   }
32780   arg1 = *argp1;
32781   {
32782     try {
32783       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32784     } catch (std::out_of_range& e) {
32785       {
32786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (std::exception& e) {
32789       {
32790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32791       };
32792     } catch (Dali::DaliException e) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32795       };
32796     } catch (...) {
32797       {
32798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32799       };
32800     }
32801   }
32802
32803   jresult = (void *)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32809   void * jresult ;
32810   Dali::Actor *arg1 ;
32811   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32812
32813   arg1 = (Dali::Actor *)jarg1;
32814   {
32815     try {
32816       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32817     } catch (std::out_of_range& e) {
32818       {
32819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (std::exception& e) {
32822       {
32823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32824       };
32825     } catch (Dali::DaliException e) {
32826       {
32827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32828       };
32829     } catch (...) {
32830       {
32831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32832       };
32833     }
32834   }
32835
32836   jresult = (void *)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::SIZE;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::POSITION;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::POSITION_X;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::POSITION_Y;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::POSITION_Z;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::WORLD_POSITION;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::ORIENTATION;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::SCALE;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::SCALE_X;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::SCALE_Y;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::SCALE_Z;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_SCALE;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::VISIBLE;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::COLOR;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::COLOR_RED;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::COLOR_GREEN;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::COLOR_BLUE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::WORLD_COLOR;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::NAME;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::SENSITIVE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_MODE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::DRAW_MODE;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::PADDING;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33372   void * jresult ;
33373   Dali::Actor::Property *result = 0 ;
33374
33375   {
33376     try {
33377       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33378     } catch (std::out_of_range& e) {
33379       {
33380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33381       };
33382     } catch (std::exception& e) {
33383       {
33384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33385       };
33386     } catch (Dali::DaliException e) {
33387       {
33388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33389       };
33390     } catch (...) {
33391       {
33392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33393       };
33394     }
33395   }
33396
33397   jresult = (void *)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33403   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33404
33405   arg1 = (Dali::Actor::Property *)jarg1;
33406   {
33407     try {
33408       delete arg1;
33409     } catch (std::out_of_range& e) {
33410       {
33411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33412       };
33413     } catch (std::exception& e) {
33414       {
33415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33416       };
33417     } catch (Dali::DaliException e) {
33418       {
33419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33420       };
33421     } catch (...) {
33422       {
33423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33424       };
33425     }
33426   }
33427
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33432   void * jresult ;
33433   Dali::Actor *result = 0 ;
33434
33435   {
33436     try {
33437       result = (Dali::Actor *)new Dali::Actor();
33438     } catch (std::out_of_range& e) {
33439       {
33440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33441       };
33442     } catch (std::exception& e) {
33443       {
33444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (Dali::DaliException e) {
33447       {
33448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456
33457   jresult = (void *)result;
33458   return jresult;
33459 }
33460
33461
33462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33463   void * jresult ;
33464   Dali::Actor result;
33465
33466   {
33467     try {
33468       result = Dali::Actor::New();
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487
33488   jresult = new Dali::Actor((const Dali::Actor &)result);
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33494   void * jresult ;
33495   Dali::BaseHandle arg1 ;
33496   Dali::BaseHandle *argp1 ;
33497   Dali::Actor result;
33498
33499   argp1 = (Dali::BaseHandle *)jarg1;
33500   if (!argp1) {
33501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33502     return 0;
33503   }
33504   arg1 = *argp1;
33505   {
33506     try {
33507       result = Dali::Actor::DownCast(arg1);
33508     } catch (std::out_of_range& e) {
33509       {
33510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33511       };
33512     } catch (std::exception& e) {
33513       {
33514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33515       };
33516     } catch (Dali::DaliException e) {
33517       {
33518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33519       };
33520     } catch (...) {
33521       {
33522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33523       };
33524     }
33525   }
33526
33527   jresult = new Dali::Actor((const Dali::Actor &)result);
33528   return jresult;
33529 }
33530
33531
33532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33534
33535   arg1 = (Dali::Actor *)jarg1;
33536   {
33537     try {
33538       delete arg1;
33539     } catch (std::out_of_range& e) {
33540       {
33541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33542       };
33543     } catch (std::exception& e) {
33544       {
33545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33546       };
33547     } catch (Dali::DaliException e) {
33548       {
33549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33550       };
33551     } catch (...) {
33552       {
33553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33554       };
33555     }
33556   }
33557
33558 }
33559
33560
33561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33562   void * jresult ;
33563   Dali::Actor *arg1 = 0 ;
33564   Dali::Actor *result = 0 ;
33565
33566   arg1 = (Dali::Actor *)jarg1;
33567   if (!arg1) {
33568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33569     return 0;
33570   }
33571   {
33572     try {
33573       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33574     } catch (std::out_of_range& e) {
33575       {
33576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (std::exception& e) {
33579       {
33580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33581       };
33582     } catch (Dali::DaliException e) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33585       };
33586     } catch (...) {
33587       {
33588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33589       };
33590     }
33591   }
33592
33593   jresult = (void *)result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33599   void * jresult ;
33600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33601   Dali::Actor *arg2 = 0 ;
33602   Dali::Actor *result = 0 ;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   arg2 = (Dali::Actor *)jarg2;
33606   if (!arg2) {
33607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33608     return 0;
33609   }
33610   {
33611     try {
33612       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33613     } catch (std::out_of_range& e) {
33614       {
33615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (std::exception& e) {
33618       {
33619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33620       };
33621     } catch (Dali::DaliException e) {
33622       {
33623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33624       };
33625     } catch (...) {
33626       {
33627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33628       };
33629     }
33630   }
33631
33632   jresult = (void *)result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33638   char * jresult ;
33639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33640   std::string *result = 0 ;
33641
33642   arg1 = (Dali::Actor *)jarg1;
33643   {
33644     try {
33645       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33646     } catch (std::out_of_range& e) {
33647       {
33648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33649       };
33650     } catch (std::exception& e) {
33651       {
33652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33653       };
33654     } catch (Dali::DaliException e) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33657       };
33658     } catch (...) {
33659       {
33660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33661       };
33662     }
33663   }
33664
33665   jresult = SWIG_csharp_string_callback(result->c_str());
33666   return jresult;
33667 }
33668
33669
33670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33672   std::string *arg2 = 0 ;
33673
33674   arg1 = (Dali::Actor *)jarg1;
33675   if (!jarg2) {
33676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33677     return ;
33678   }
33679   std::string arg2_str(jarg2);
33680   arg2 = &arg2_str;
33681   {
33682     try {
33683       (arg1)->SetName((std::string const &)*arg2);
33684     } catch (std::out_of_range& e) {
33685       {
33686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33687       };
33688     } catch (std::exception& e) {
33689       {
33690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33691       };
33692     } catch (Dali::DaliException e) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33699       };
33700     }
33701   }
33702
33703
33704   //argout typemap for const std::string&
33705
33706 }
33707
33708
33709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33710   unsigned int jresult ;
33711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33712   unsigned int result;
33713
33714   arg1 = (Dali::Actor *)jarg1;
33715   {
33716     try {
33717       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33733       };
33734     }
33735   }
33736
33737   jresult = result;
33738   return jresult;
33739 }
33740
33741
33742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33743   unsigned int jresult ;
33744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33745   bool result;
33746
33747   arg1 = (Dali::Actor *)jarg1;
33748   {
33749     try {
33750       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33751     } catch (std::out_of_range& e) {
33752       {
33753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33754       };
33755     } catch (std::exception& e) {
33756       {
33757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33758       };
33759     } catch (Dali::DaliException e) {
33760       {
33761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33762       };
33763     } catch (...) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33766       };
33767     }
33768   }
33769
33770   jresult = result;
33771   return jresult;
33772 }
33773
33774
33775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33776   unsigned int jresult ;
33777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33778   bool result;
33779
33780   arg1 = (Dali::Actor *)jarg1;
33781   {
33782     try {
33783       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33784     } catch (std::out_of_range& e) {
33785       {
33786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33787       };
33788     } catch (std::exception& e) {
33789       {
33790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33791       };
33792     } catch (Dali::DaliException e) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33799       };
33800     }
33801   }
33802
33803   jresult = result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33809   unsigned int jresult ;
33810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33811   bool result;
33812
33813   arg1 = (Dali::Actor *)jarg1;
33814   {
33815     try {
33816       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (Dali::DaliException e) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33828       };
33829     } catch (...) {
33830       {
33831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33832       };
33833     }
33834   }
33835
33836   jresult = result;
33837   return jresult;
33838 }
33839
33840
33841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33842   void * jresult ;
33843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33844   Dali::Layer result;
33845
33846   arg1 = (Dali::Actor *)jarg1;
33847   {
33848     try {
33849       result = (arg1)->GetLayer();
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (Dali::DaliException e) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33861       };
33862     } catch (...) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33865       };
33866     }
33867   }
33868
33869   jresult = new Dali::Layer((const Dali::Layer &)result);
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33876   Dali::Actor arg2 ;
33877   Dali::Actor *argp2 ;
33878
33879   arg1 = (Dali::Actor *)jarg1;
33880   argp2 = (Dali::Actor *)jarg2;
33881   if (!argp2) {
33882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33883     return ;
33884   }
33885   arg2 = *argp2;
33886   {
33887     try {
33888       (arg1)->Add(arg2);
33889     } catch (std::out_of_range& e) {
33890       {
33891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33892       };
33893     } catch (std::exception& e) {
33894       {
33895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33896       };
33897     } catch (Dali::DaliException e) {
33898       {
33899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33900       };
33901     } catch (...) {
33902       {
33903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33904       };
33905     }
33906   }
33907
33908 }
33909
33910
33911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33913   Dali::Actor arg2 ;
33914   Dali::Actor *argp2 ;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   argp2 = (Dali::Actor *)jarg2;
33918   if (!argp2) {
33919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33920     return ;
33921   }
33922   arg2 = *argp2;
33923   {
33924     try {
33925       (arg1)->Remove(arg2);
33926     } catch (std::out_of_range& e) {
33927       {
33928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33929       };
33930     } catch (std::exception& e) {
33931       {
33932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33933       };
33934     } catch (Dali::DaliException e) {
33935       {
33936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33937       };
33938     } catch (...) {
33939       {
33940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33941       };
33942     }
33943   }
33944
33945 }
33946
33947
33948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950
33951   arg1 = (Dali::Actor *)jarg1;
33952   {
33953     try {
33954       (arg1)->Unparent();
33955     } catch (std::out_of_range& e) {
33956       {
33957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33958       };
33959     } catch (std::exception& e) {
33960       {
33961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33962       };
33963     } catch (Dali::DaliException e) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33970       };
33971     }
33972   }
33973
33974 }
33975
33976
33977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33978   unsigned int jresult ;
33979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33980   unsigned int result;
33981
33982   arg1 = (Dali::Actor *)jarg1;
33983   {
33984     try {
33985       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = result;
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   unsigned int arg2 ;
34014   Dali::Actor result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   arg2 = (unsigned int)jarg2;
34018   {
34019     try {
34020       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34021     } catch (std::out_of_range& e) {
34022       {
34023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34024       };
34025     } catch (std::exception& e) {
34026       {
34027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (Dali::DaliException e) {
34030       {
34031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34032       };
34033     } catch (...) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34036       };
34037     }
34038   }
34039
34040   jresult = new Dali::Actor((const Dali::Actor &)result);
34041   return jresult;
34042 }
34043
34044
34045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34046   void * jresult ;
34047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34048   std::string *arg2 = 0 ;
34049   Dali::Actor result;
34050
34051   arg1 = (Dali::Actor *)jarg1;
34052   if (!jarg2) {
34053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34054     return 0;
34055   }
34056   std::string arg2_str(jarg2);
34057   arg2 = &arg2_str;
34058   {
34059     try {
34060       result = (arg1)->FindChildByName((std::string const &)*arg2);
34061     } catch (std::out_of_range& e) {
34062       {
34063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (std::exception& e) {
34066       {
34067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34068       };
34069     } catch (Dali::DaliException e) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34072       };
34073     } catch (...) {
34074       {
34075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34076       };
34077     }
34078   }
34079
34080   jresult = new Dali::Actor((const Dali::Actor &)result);
34081
34082   //argout typemap for const std::string&
34083
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34089   void * jresult ;
34090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34091   unsigned int arg2 ;
34092   Dali::Actor result;
34093
34094   arg1 = (Dali::Actor *)jarg1;
34095   arg2 = (unsigned int)jarg2;
34096   {
34097     try {
34098       result = (arg1)->FindChildById(arg2);
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (Dali::DaliException e) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34110       };
34111     } catch (...) {
34112       {
34113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34114       };
34115     }
34116   }
34117
34118   jresult = new Dali::Actor((const Dali::Actor &)result);
34119   return jresult;
34120 }
34121
34122
34123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34124   void * jresult ;
34125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34126   Dali::Actor result;
34127
34128   arg1 = (Dali::Actor *)jarg1;
34129   {
34130     try {
34131       result = ((Dali::Actor const *)arg1)->GetParent();
34132     } catch (std::out_of_range& e) {
34133       {
34134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34135       };
34136     } catch (std::exception& e) {
34137       {
34138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34139       };
34140     } catch (Dali::DaliException e) {
34141       {
34142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34143       };
34144     } catch (...) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34147       };
34148     }
34149   }
34150
34151   jresult = new Dali::Actor((const Dali::Actor &)result);
34152   return jresult;
34153 }
34154
34155
34156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34158   Dali::Vector3 *arg2 = 0 ;
34159
34160   arg1 = (Dali::Actor *)jarg1;
34161   arg2 = (Dali::Vector3 *)jarg2;
34162   if (!arg2) {
34163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34164     return ;
34165   }
34166   {
34167     try {
34168       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34169     } catch (std::out_of_range& e) {
34170       {
34171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34172       };
34173     } catch (std::exception& e) {
34174       {
34175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34176       };
34177     } catch (Dali::DaliException e) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34180       };
34181     } catch (...) {
34182       {
34183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34184       };
34185     }
34186   }
34187
34188 }
34189
34190
34191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34192   void * jresult ;
34193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34194   Dali::Vector3 result;
34195
34196   arg1 = (Dali::Actor *)jarg1;
34197   {
34198     try {
34199       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34200     } catch (std::out_of_range& e) {
34201       {
34202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34203       };
34204     } catch (std::exception& e) {
34205       {
34206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34207       };
34208     } catch (Dali::DaliException e) {
34209       {
34210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34211       };
34212     } catch (...) {
34213       {
34214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34215       };
34216     }
34217   }
34218
34219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34220   return jresult;
34221 }
34222
34223
34224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 *arg2 = 0 ;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   arg2 = (Dali::Vector3 *)jarg2;
34230   if (!arg2) {
34231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34232     return ;
34233   }
34234   {
34235     try {
34236       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34244       };
34245     } catch (Dali::DaliException e) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34252       };
34253     }
34254   }
34255
34256 }
34257
34258
34259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34260   void * jresult ;
34261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34262   Dali::Vector3 result;
34263
34264   arg1 = (Dali::Actor *)jarg1;
34265   {
34266     try {
34267       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34294   float arg2 ;
34295   float arg3 ;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   arg2 = (float)jarg2;
34299   arg3 = (float)jarg3;
34300   {
34301     try {
34302       (arg1)->SetSize(arg2,arg3);
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34310       };
34311     } catch (Dali::DaliException e) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34318       };
34319     }
34320   }
34321
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   float arg2 ;
34328   float arg3 ;
34329   float arg4 ;
34330
34331   arg1 = (Dali::Actor *)jarg1;
34332   arg2 = (float)jarg2;
34333   arg3 = (float)jarg3;
34334   arg4 = (float)jarg4;
34335   {
34336     try {
34337       (arg1)->SetSize(arg2,arg3,arg4);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34362   Dali::Vector2 *arg2 = 0 ;
34363
34364   arg1 = (Dali::Actor *)jarg1;
34365   arg2 = (Dali::Vector2 *)jarg2;
34366   if (!arg2) {
34367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34368     return ;
34369   }
34370   {
34371     try {
34372       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34373     } catch (std::out_of_range& e) {
34374       {
34375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34376       };
34377     } catch (std::exception& e) {
34378       {
34379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34380       };
34381     } catch (Dali::DaliException e) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34384       };
34385     } catch (...) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34388       };
34389     }
34390   }
34391
34392 }
34393
34394
34395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34397   Dali::Vector3 *arg2 = 0 ;
34398
34399   arg1 = (Dali::Actor *)jarg1;
34400   arg2 = (Dali::Vector3 *)jarg2;
34401   if (!arg2) {
34402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34403     return ;
34404   }
34405   {
34406     try {
34407       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34408     } catch (std::out_of_range& e) {
34409       {
34410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34411       };
34412     } catch (std::exception& e) {
34413       {
34414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34415       };
34416     } catch (Dali::DaliException e) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34419       };
34420     } catch (...) {
34421       {
34422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34423       };
34424     }
34425   }
34426
34427 }
34428
34429
34430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34431   void * jresult ;
34432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34433   Dali::Vector3 result;
34434
34435   arg1 = (Dali::Actor *)jarg1;
34436   {
34437     try {
34438       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34439     } catch (std::out_of_range& e) {
34440       {
34441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34442       };
34443     } catch (std::exception& e) {
34444       {
34445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34446       };
34447     } catch (Dali::DaliException e) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34450       };
34451     } catch (...) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34454       };
34455     }
34456   }
34457
34458   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34459   return jresult;
34460 }
34461
34462
34463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34464   void * jresult ;
34465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34466   Dali::Vector3 result;
34467
34468   arg1 = (Dali::Actor *)jarg1;
34469   {
34470     try {
34471       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (Dali::DaliException e) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34483       };
34484     } catch (...) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34487       };
34488     }
34489   }
34490
34491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34492   return jresult;
34493 }
34494
34495
34496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34497   void * jresult ;
34498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34499   Dali::Vector3 result;
34500
34501   arg1 = (Dali::Actor *)jarg1;
34502   {
34503     try {
34504       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (Dali::DaliException e) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34516       };
34517     } catch (...) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34520       };
34521     }
34522   }
34523
34524   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34525   return jresult;
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34531   float arg2 ;
34532   float arg3 ;
34533
34534   arg1 = (Dali::Actor *)jarg1;
34535   arg2 = (float)jarg2;
34536   arg3 = (float)jarg3;
34537   {
34538     try {
34539       (arg1)->SetPosition(arg2,arg3);
34540     } catch (std::out_of_range& e) {
34541       {
34542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (std::exception& e) {
34545       {
34546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (Dali::DaliException e) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558
34559 }
34560
34561
34562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34564   float arg2 ;
34565   float arg3 ;
34566   float arg4 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (float)jarg2;
34570   arg3 = (float)jarg3;
34571   arg4 = (float)jarg4;
34572   {
34573     try {
34574       (arg1)->SetPosition(arg2,arg3,arg4);
34575     } catch (std::out_of_range& e) {
34576       {
34577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (std::exception& e) {
34580       {
34581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34582       };
34583     } catch (Dali::DaliException e) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34590       };
34591     }
34592   }
34593
34594 }
34595
34596
34597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34599   Dali::Vector3 *arg2 = 0 ;
34600
34601   arg1 = (Dali::Actor *)jarg1;
34602   arg2 = (Dali::Vector3 *)jarg2;
34603   if (!arg2) {
34604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34605     return ;
34606   }
34607   {
34608     try {
34609       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34610     } catch (std::out_of_range& e) {
34611       {
34612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34613       };
34614     } catch (std::exception& e) {
34615       {
34616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34617       };
34618     } catch (Dali::DaliException e) {
34619       {
34620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34621       };
34622     } catch (...) {
34623       {
34624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34625       };
34626     }
34627   }
34628
34629 }
34630
34631
34632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34634   float arg2 ;
34635
34636   arg1 = (Dali::Actor *)jarg1;
34637   arg2 = (float)jarg2;
34638   {
34639     try {
34640       (arg1)->SetX(arg2);
34641     } catch (std::out_of_range& e) {
34642       {
34643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34644       };
34645     } catch (std::exception& e) {
34646       {
34647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34648       };
34649     } catch (Dali::DaliException e) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34656       };
34657     }
34658   }
34659
34660 }
34661
34662
34663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34665   float arg2 ;
34666
34667   arg1 = (Dali::Actor *)jarg1;
34668   arg2 = (float)jarg2;
34669   {
34670     try {
34671       (arg1)->SetY(arg2);
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34679       };
34680     } catch (Dali::DaliException e) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34687       };
34688     }
34689   }
34690
34691 }
34692
34693
34694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34696   float arg2 ;
34697
34698   arg1 = (Dali::Actor *)jarg1;
34699   arg2 = (float)jarg2;
34700   {
34701     try {
34702       (arg1)->SetZ(arg2);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (Dali::DaliException e) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721
34722 }
34723
34724
34725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34727   Dali::Vector3 *arg2 = 0 ;
34728
34729   arg1 = (Dali::Actor *)jarg1;
34730   arg2 = (Dali::Vector3 *)jarg2;
34731   if (!arg2) {
34732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34733     return ;
34734   }
34735   {
34736     try {
34737       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34738     } catch (std::out_of_range& e) {
34739       {
34740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34741       };
34742     } catch (std::exception& e) {
34743       {
34744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34745       };
34746     } catch (Dali::DaliException e) {
34747       {
34748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34749       };
34750     } catch (...) {
34751       {
34752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34753       };
34754     }
34755   }
34756
34757 }
34758
34759
34760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34761   void * jresult ;
34762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34763   Dali::Vector3 result;
34764
34765   arg1 = (Dali::Actor *)jarg1;
34766   {
34767     try {
34768       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34769     } catch (std::out_of_range& e) {
34770       {
34771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34772       };
34773     } catch (std::exception& e) {
34774       {
34775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34776       };
34777     } catch (Dali::DaliException e) {
34778       {
34779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34780       };
34781     } catch (...) {
34782       {
34783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34784       };
34785     }
34786   }
34787
34788   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34789   return jresult;
34790 }
34791
34792
34793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34794   void * jresult ;
34795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34796   Dali::Vector3 result;
34797
34798   arg1 = (Dali::Actor *)jarg1;
34799   {
34800     try {
34801       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34802     } catch (std::out_of_range& e) {
34803       {
34804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34805       };
34806     } catch (std::exception& e) {
34807       {
34808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34809       };
34810     } catch (Dali::DaliException e) {
34811       {
34812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34813       };
34814     } catch (...) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34817       };
34818     }
34819   }
34820
34821   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34828   bool arg2 ;
34829
34830   arg1 = (Dali::Actor *)jarg1;
34831   arg2 = jarg2 ? true : false;
34832   {
34833     try {
34834       (arg1)->SetInheritPosition(arg2);
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (Dali::DaliException e) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34846       };
34847     } catch (...) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34850       };
34851     }
34852   }
34853
34854 }
34855
34856
34857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34858   unsigned int jresult ;
34859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34860   bool result;
34861
34862   arg1 = (Dali::Actor *)jarg1;
34863   {
34864     try {
34865       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34866     } catch (std::out_of_range& e) {
34867       {
34868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34869       };
34870     } catch (std::exception& e) {
34871       {
34872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34873       };
34874     } catch (Dali::DaliException e) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34877       };
34878     } catch (...) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34881       };
34882     }
34883   }
34884
34885   jresult = result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Degree *arg2 = 0 ;
34893   Dali::Vector3 *arg3 = 0 ;
34894
34895   arg1 = (Dali::Actor *)jarg1;
34896   arg2 = (Dali::Degree *)jarg2;
34897   if (!arg2) {
34898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34899     return ;
34900   }
34901   arg3 = (Dali::Vector3 *)jarg3;
34902   if (!arg3) {
34903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34904     return ;
34905   }
34906   {
34907     try {
34908       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34909     } catch (std::out_of_range& e) {
34910       {
34911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34912       };
34913     } catch (std::exception& e) {
34914       {
34915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34916       };
34917     } catch (Dali::DaliException e) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34920       };
34921     } catch (...) {
34922       {
34923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34924       };
34925     }
34926   }
34927
34928 }
34929
34930
34931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34933   Dali::Radian *arg2 = 0 ;
34934   Dali::Vector3 *arg3 = 0 ;
34935
34936   arg1 = (Dali::Actor *)jarg1;
34937   arg2 = (Dali::Radian *)jarg2;
34938   if (!arg2) {
34939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34940     return ;
34941   }
34942   arg3 = (Dali::Vector3 *)jarg3;
34943   if (!arg3) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34945     return ;
34946   }
34947   {
34948     try {
34949       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34950     } catch (std::out_of_range& e) {
34951       {
34952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34953       };
34954     } catch (std::exception& e) {
34955       {
34956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34957       };
34958     } catch (Dali::DaliException e) {
34959       {
34960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34965       };
34966     }
34967   }
34968
34969 }
34970
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34974   Dali::Quaternion *arg2 = 0 ;
34975
34976   arg1 = (Dali::Actor *)jarg1;
34977   arg2 = (Dali::Quaternion *)jarg2;
34978   if (!arg2) {
34979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34980     return ;
34981   }
34982   {
34983     try {
34984       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34985     } catch (std::out_of_range& e) {
34986       {
34987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34988       };
34989     } catch (std::exception& e) {
34990       {
34991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (Dali::DaliException e) {
34994       {
34995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34996       };
34997     } catch (...) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35000       };
35001     }
35002   }
35003
35004 }
35005
35006
35007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35009   Dali::Degree *arg2 = 0 ;
35010   Dali::Vector3 *arg3 = 0 ;
35011
35012   arg1 = (Dali::Actor *)jarg1;
35013   arg2 = (Dali::Degree *)jarg2;
35014   if (!arg2) {
35015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35016     return ;
35017   }
35018   arg3 = (Dali::Vector3 *)jarg3;
35019   if (!arg3) {
35020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35021     return ;
35022   }
35023   {
35024     try {
35025       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35033       };
35034     } catch (Dali::DaliException e) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35041       };
35042     }
35043   }
35044
35045 }
35046
35047
35048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35050   Dali::Radian *arg2 = 0 ;
35051   Dali::Vector3 *arg3 = 0 ;
35052
35053   arg1 = (Dali::Actor *)jarg1;
35054   arg2 = (Dali::Radian *)jarg2;
35055   if (!arg2) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35057     return ;
35058   }
35059   arg3 = (Dali::Vector3 *)jarg3;
35060   if (!arg3) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35062     return ;
35063   }
35064   {
35065     try {
35066       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35067     } catch (std::out_of_range& e) {
35068       {
35069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35070       };
35071     } catch (std::exception& e) {
35072       {
35073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35074       };
35075     } catch (Dali::DaliException e) {
35076       {
35077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35078       };
35079     } catch (...) {
35080       {
35081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35082       };
35083     }
35084   }
35085
35086 }
35087
35088
35089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35091   Dali::Quaternion *arg2 = 0 ;
35092
35093   arg1 = (Dali::Actor *)jarg1;
35094   arg2 = (Dali::Quaternion *)jarg2;
35095   if (!arg2) {
35096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35097     return ;
35098   }
35099   {
35100     try {
35101       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35102     } catch (std::out_of_range& e) {
35103       {
35104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35105       };
35106     } catch (std::exception& e) {
35107       {
35108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (Dali::DaliException e) {
35111       {
35112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35117       };
35118     }
35119   }
35120
35121 }
35122
35123
35124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35125   void * jresult ;
35126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35127   Dali::Quaternion result;
35128
35129   arg1 = (Dali::Actor *)jarg1;
35130   {
35131     try {
35132       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35133     } catch (std::out_of_range& e) {
35134       {
35135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35136       };
35137     } catch (std::exception& e) {
35138       {
35139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35140       };
35141     } catch (Dali::DaliException e) {
35142       {
35143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35144       };
35145     } catch (...) {
35146       {
35147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35148       };
35149     }
35150   }
35151
35152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35159   bool arg2 ;
35160
35161   arg1 = (Dali::Actor *)jarg1;
35162   arg2 = jarg2 ? true : false;
35163   {
35164     try {
35165       (arg1)->SetInheritOrientation(arg2);
35166     } catch (std::out_of_range& e) {
35167       {
35168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (std::exception& e) {
35171       {
35172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35173       };
35174     } catch (Dali::DaliException e) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35177       };
35178     } catch (...) {
35179       {
35180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35181       };
35182     }
35183   }
35184
35185 }
35186
35187
35188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35189   unsigned int jresult ;
35190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35191   bool result;
35192
35193   arg1 = (Dali::Actor *)jarg1;
35194   {
35195     try {
35196       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35197     } catch (std::out_of_range& e) {
35198       {
35199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35200       };
35201     } catch (std::exception& e) {
35202       {
35203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35204       };
35205     } catch (Dali::DaliException e) {
35206       {
35207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35208       };
35209     } catch (...) {
35210       {
35211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35212       };
35213     }
35214   }
35215
35216   jresult = result;
35217   return jresult;
35218 }
35219
35220
35221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35222   void * jresult ;
35223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35224   Dali::Quaternion result;
35225
35226   arg1 = (Dali::Actor *)jarg1;
35227   {
35228     try {
35229       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35237       };
35238     } catch (Dali::DaliException e) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35241       };
35242     } catch (...) {
35243       {
35244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35245       };
35246     }
35247   }
35248
35249   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35250   return jresult;
35251 }
35252
35253
35254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35256   float arg2 ;
35257
35258   arg1 = (Dali::Actor *)jarg1;
35259   arg2 = (float)jarg2;
35260   {
35261     try {
35262       (arg1)->SetScale(arg2);
35263     } catch (std::out_of_range& e) {
35264       {
35265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35266       };
35267     } catch (std::exception& e) {
35268       {
35269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (Dali::DaliException e) {
35272       {
35273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35274       };
35275     } catch (...) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35278       };
35279     }
35280   }
35281
35282 }
35283
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   float arg2 ;
35288   float arg3 ;
35289   float arg4 ;
35290
35291   arg1 = (Dali::Actor *)jarg1;
35292   arg2 = (float)jarg2;
35293   arg3 = (float)jarg3;
35294   arg4 = (float)jarg4;
35295   {
35296     try {
35297       (arg1)->SetScale(arg2,arg3,arg4);
35298     } catch (std::out_of_range& e) {
35299       {
35300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35301       };
35302     } catch (std::exception& e) {
35303       {
35304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (Dali::DaliException e) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35309       };
35310     } catch (...) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35313       };
35314     }
35315   }
35316
35317 }
35318
35319
35320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35322   Dali::Vector3 *arg2 = 0 ;
35323
35324   arg1 = (Dali::Actor *)jarg1;
35325   arg2 = (Dali::Vector3 *)jarg2;
35326   if (!arg2) {
35327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35328     return ;
35329   }
35330   {
35331     try {
35332       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35357   Dali::Vector3 *arg2 = 0 ;
35358
35359   arg1 = (Dali::Actor *)jarg1;
35360   arg2 = (Dali::Vector3 *)jarg2;
35361   if (!arg2) {
35362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35363     return ;
35364   }
35365   {
35366     try {
35367       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35368     } catch (std::out_of_range& e) {
35369       {
35370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35371       };
35372     } catch (std::exception& e) {
35373       {
35374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (Dali::DaliException e) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35379       };
35380     } catch (...) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35383       };
35384     }
35385   }
35386
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35391   void * jresult ;
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   Dali::Vector3 result;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   {
35397     try {
35398       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35399     } catch (std::out_of_range& e) {
35400       {
35401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (std::exception& e) {
35404       {
35405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (Dali::DaliException e) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417
35418   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35424   void * jresult ;
35425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35426   Dali::Vector3 result;
35427
35428   arg1 = (Dali::Actor *)jarg1;
35429   {
35430     try {
35431       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35432     } catch (std::out_of_range& e) {
35433       {
35434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35435       };
35436     } catch (std::exception& e) {
35437       {
35438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35439       };
35440     } catch (Dali::DaliException e) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35443       };
35444     } catch (...) {
35445       {
35446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35447       };
35448     }
35449   }
35450
35451   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35452   return jresult;
35453 }
35454
35455
35456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35458   bool arg2 ;
35459
35460   arg1 = (Dali::Actor *)jarg1;
35461   arg2 = jarg2 ? true : false;
35462   {
35463     try {
35464       (arg1)->SetInheritScale(arg2);
35465     } catch (std::out_of_range& e) {
35466       {
35467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35468       };
35469     } catch (std::exception& e) {
35470       {
35471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35472       };
35473     } catch (Dali::DaliException e) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35476       };
35477     } catch (...) {
35478       {
35479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35480       };
35481     }
35482   }
35483
35484 }
35485
35486
35487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35488   unsigned int jresult ;
35489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35490   bool result;
35491
35492   arg1 = (Dali::Actor *)jarg1;
35493   {
35494     try {
35495       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35496     } catch (std::out_of_range& e) {
35497       {
35498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35499       };
35500     } catch (std::exception& e) {
35501       {
35502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35503       };
35504     } catch (Dali::DaliException e) {
35505       {
35506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35507       };
35508     } catch (...) {
35509       {
35510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35511       };
35512     }
35513   }
35514
35515   jresult = result;
35516   return jresult;
35517 }
35518
35519
35520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35521   void * jresult ;
35522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35523   Dali::Matrix result;
35524
35525   arg1 = (Dali::Actor *)jarg1;
35526   {
35527     try {
35528       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35536       };
35537     } catch (Dali::DaliException e) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35540       };
35541     } catch (...) {
35542       {
35543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35544       };
35545     }
35546   }
35547
35548   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35549   return jresult;
35550 }
35551
35552
35553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35555   bool arg2 ;
35556
35557   arg1 = (Dali::Actor *)jarg1;
35558   arg2 = jarg2 ? true : false;
35559   {
35560     try {
35561       (arg1)->SetVisible(arg2);
35562     } catch (std::out_of_range& e) {
35563       {
35564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35565       };
35566     } catch (std::exception& e) {
35567       {
35568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35569       };
35570     } catch (Dali::DaliException e) {
35571       {
35572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35573       };
35574     } catch (...) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35577       };
35578     }
35579   }
35580
35581 }
35582
35583
35584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35585   unsigned int jresult ;
35586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35587   bool result;
35588
35589   arg1 = (Dali::Actor *)jarg1;
35590   {
35591     try {
35592       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35593     } catch (std::out_of_range& e) {
35594       {
35595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35596       };
35597     } catch (std::exception& e) {
35598       {
35599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35600       };
35601     } catch (Dali::DaliException e) {
35602       {
35603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35604       };
35605     } catch (...) {
35606       {
35607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35608       };
35609     }
35610   }
35611
35612   jresult = result;
35613   return jresult;
35614 }
35615
35616
35617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   float arg2 ;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   arg2 = (float)jarg2;
35623   {
35624     try {
35625       (arg1)->SetOpacity(arg2);
35626     } catch (std::out_of_range& e) {
35627       {
35628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35629       };
35630     } catch (std::exception& e) {
35631       {
35632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (Dali::DaliException e) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35637       };
35638     } catch (...) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35641       };
35642     }
35643   }
35644
35645 }
35646
35647
35648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35649   float jresult ;
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   float result;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   {
35655     try {
35656       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (Dali::DaliException e) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35668       };
35669     } catch (...) {
35670       {
35671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35672       };
35673     }
35674   }
35675
35676   jresult = result;
35677   return jresult;
35678 }
35679
35680
35681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   Dali::Vector4 *arg2 = 0 ;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   arg2 = (Dali::Vector4 *)jarg2;
35687   if (!arg2) {
35688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35689     return ;
35690   }
35691   {
35692     try {
35693       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35694     } catch (std::out_of_range& e) {
35695       {
35696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35697       };
35698     } catch (std::exception& e) {
35699       {
35700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35701       };
35702     } catch (Dali::DaliException e) {
35703       {
35704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35709       };
35710     }
35711   }
35712
35713 }
35714
35715
35716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35717   void * jresult ;
35718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35719   Dali::Vector4 result;
35720
35721   arg1 = (Dali::Actor *)jarg1;
35722   {
35723     try {
35724       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35725     } catch (std::out_of_range& e) {
35726       {
35727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35728       };
35729     } catch (std::exception& e) {
35730       {
35731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35732       };
35733     } catch (Dali::DaliException e) {
35734       {
35735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35740       };
35741     }
35742   }
35743
35744   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35745   return jresult;
35746 }
35747
35748
35749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35751   Dali::ColorMode arg2 ;
35752
35753   arg1 = (Dali::Actor *)jarg1;
35754   arg2 = (Dali::ColorMode)jarg2;
35755   {
35756     try {
35757       (arg1)->SetColorMode(arg2);
35758     } catch (std::out_of_range& e) {
35759       {
35760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35761       };
35762     } catch (std::exception& e) {
35763       {
35764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35765       };
35766     } catch (Dali::DaliException e) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35769       };
35770     } catch (...) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35773       };
35774     }
35775   }
35776
35777 }
35778
35779
35780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35781   int jresult ;
35782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35783   Dali::ColorMode result;
35784
35785   arg1 = (Dali::Actor *)jarg1;
35786   {
35787     try {
35788       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35789     } catch (std::out_of_range& e) {
35790       {
35791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35792       };
35793     } catch (std::exception& e) {
35794       {
35795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35796       };
35797     } catch (Dali::DaliException e) {
35798       {
35799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35800       };
35801     } catch (...) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35804       };
35805     }
35806   }
35807
35808   jresult = (int)result;
35809   return jresult;
35810 }
35811
35812
35813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35814   void * jresult ;
35815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35816   Dali::Vector4 result;
35817
35818   arg1 = (Dali::Actor *)jarg1;
35819   {
35820     try {
35821       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35822     } catch (std::out_of_range& e) {
35823       {
35824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35825       };
35826     } catch (std::exception& e) {
35827       {
35828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (Dali::DaliException e) {
35831       {
35832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35833       };
35834     } catch (...) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35837       };
35838     }
35839   }
35840
35841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35842   return jresult;
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35848   Dali::DrawMode::Type arg2 ;
35849
35850   arg1 = (Dali::Actor *)jarg1;
35851   arg2 = (Dali::DrawMode::Type)jarg2;
35852   {
35853     try {
35854       (arg1)->SetDrawMode(arg2);
35855     } catch (std::out_of_range& e) {
35856       {
35857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35858       };
35859     } catch (std::exception& e) {
35860       {
35861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35862       };
35863     } catch (Dali::DaliException e) {
35864       {
35865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35866       };
35867     } catch (...) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35870       };
35871     }
35872   }
35873
35874 }
35875
35876
35877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35878   int jresult ;
35879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35880   Dali::DrawMode::Type result;
35881
35882   arg1 = (Dali::Actor *)jarg1;
35883   {
35884     try {
35885       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35886     } catch (std::out_of_range& e) {
35887       {
35888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35889       };
35890     } catch (std::exception& e) {
35891       {
35892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (Dali::DaliException e) {
35895       {
35896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35897       };
35898     } catch (...) {
35899       {
35900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35901       };
35902     }
35903   }
35904
35905   jresult = (int)result;
35906   return jresult;
35907 }
35908
35909
35910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   bool arg2 ;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   arg2 = jarg2 ? true : false;
35916   {
35917     try {
35918       (arg1)->SetSensitive(arg2);
35919     } catch (std::out_of_range& e) {
35920       {
35921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35922       };
35923     } catch (std::exception& e) {
35924       {
35925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35926       };
35927     } catch (Dali::DaliException e) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35930       };
35931     } catch (...) {
35932       {
35933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35934       };
35935     }
35936   }
35937
35938 }
35939
35940
35941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35942   unsigned int jresult ;
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   bool result;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   {
35948     try {
35949       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35950     } catch (std::out_of_range& e) {
35951       {
35952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35953       };
35954     } catch (std::exception& e) {
35955       {
35956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (Dali::DaliException e) {
35959       {
35960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35961       };
35962     } catch (...) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35965       };
35966     }
35967   }
35968
35969   jresult = result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35975   unsigned int jresult ;
35976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35977   float *arg2 = 0 ;
35978   float *arg3 = 0 ;
35979   float arg4 ;
35980   float arg5 ;
35981   bool result;
35982
35983   arg1 = (Dali::Actor *)jarg1;
35984   arg2 = (float *)jarg2;
35985   arg3 = (float *)jarg3;
35986   arg4 = (float)jarg4;
35987   arg5 = (float)jarg5;
35988   {
35989     try {
35990       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = result;
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36017   bool arg2 ;
36018
36019   arg1 = (Dali::Actor *)jarg1;
36020   arg2 = jarg2 ? true : false;
36021   {
36022     try {
36023       (arg1)->SetLeaveRequired(arg2);
36024     } catch (std::out_of_range& e) {
36025       {
36026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (std::exception& e) {
36029       {
36030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36031       };
36032     } catch (Dali::DaliException e) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36039       };
36040     }
36041   }
36042
36043 }
36044
36045
36046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36047   unsigned int jresult ;
36048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36049   bool result;
36050
36051   arg1 = (Dali::Actor *)jarg1;
36052   {
36053     try {
36054       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (Dali::DaliException e) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073
36074   jresult = result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   bool arg2 ;
36082
36083   arg1 = (Dali::Actor *)jarg1;
36084   arg2 = jarg2 ? true : false;
36085   {
36086     try {
36087       (arg1)->SetKeyboardFocusable(arg2);
36088     } catch (std::out_of_range& e) {
36089       {
36090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (std::exception& e) {
36093       {
36094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36095       };
36096     } catch (Dali::DaliException e) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36103       };
36104     }
36105   }
36106
36107 }
36108
36109
36110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36111   unsigned int jresult ;
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool result;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   {
36117     try {
36118       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36134       };
36135     }
36136   }
36137
36138   jresult = result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   Dali::ResizePolicy::Type arg2 ;
36146   Dali::Dimension::Type arg3 ;
36147
36148   arg1 = (Dali::Actor *)jarg1;
36149   arg2 = (Dali::ResizePolicy::Type)jarg2;
36150   arg3 = (Dali::Dimension::Type)jarg3;
36151   {
36152     try {
36153       (arg1)->SetResizePolicy(arg2,arg3);
36154     } catch (std::out_of_range& e) {
36155       {
36156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36157       };
36158     } catch (std::exception& e) {
36159       {
36160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36161       };
36162     } catch (Dali::DaliException e) {
36163       {
36164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36165       };
36166     } catch (...) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36169       };
36170     }
36171   }
36172
36173 }
36174
36175
36176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36177   int jresult ;
36178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36179   Dali::Dimension::Type arg2 ;
36180   Dali::ResizePolicy::Type result;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   arg2 = (Dali::Dimension::Type)jarg2;
36184   {
36185     try {
36186       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36187     } catch (std::out_of_range& e) {
36188       {
36189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36190       };
36191     } catch (std::exception& e) {
36192       {
36193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36194       };
36195     } catch (Dali::DaliException e) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36198       };
36199     } catch (...) {
36200       {
36201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36202       };
36203     }
36204   }
36205
36206   jresult = (int)result;
36207   return jresult;
36208 }
36209
36210
36211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36213   Dali::SizeScalePolicy::Type arg2 ;
36214
36215   arg1 = (Dali::Actor *)jarg1;
36216   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36217   {
36218     try {
36219       (arg1)->SetSizeScalePolicy(arg2);
36220     } catch (std::out_of_range& e) {
36221       {
36222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36223       };
36224     } catch (std::exception& e) {
36225       {
36226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36227       };
36228     } catch (Dali::DaliException e) {
36229       {
36230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36231       };
36232     } catch (...) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36235       };
36236     }
36237   }
36238
36239 }
36240
36241
36242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36243   int jresult ;
36244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36245   Dali::SizeScalePolicy::Type result;
36246
36247   arg1 = (Dali::Actor *)jarg1;
36248   {
36249     try {
36250       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36251     } catch (std::out_of_range& e) {
36252       {
36253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36254       };
36255     } catch (std::exception& e) {
36256       {
36257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (Dali::DaliException e) {
36260       {
36261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36266       };
36267     }
36268   }
36269
36270   jresult = (int)result;
36271   return jresult;
36272 }
36273
36274
36275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36277   Dali::Vector3 *arg2 = 0 ;
36278
36279   arg1 = (Dali::Actor *)jarg1;
36280   arg2 = (Dali::Vector3 *)jarg2;
36281   if (!arg2) {
36282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36283     return ;
36284   }
36285   {
36286     try {
36287       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36288     } catch (std::out_of_range& e) {
36289       {
36290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36291       };
36292     } catch (std::exception& e) {
36293       {
36294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36295       };
36296     } catch (Dali::DaliException e) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36299       };
36300     } catch (...) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36303       };
36304     }
36305   }
36306
36307 }
36308
36309
36310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36311   void * jresult ;
36312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36313   Dali::Vector3 result;
36314
36315   arg1 = (Dali::Actor *)jarg1;
36316   {
36317     try {
36318       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36319     } catch (std::out_of_range& e) {
36320       {
36321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36322       };
36323     } catch (std::exception& e) {
36324       {
36325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36326       };
36327     } catch (Dali::DaliException e) {
36328       {
36329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36330       };
36331     } catch (...) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36334       };
36335     }
36336   }
36337
36338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36339   return jresult;
36340 }
36341
36342
36343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36344   float jresult ;
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   float arg2 ;
36347   float result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (float)jarg2;
36351   {
36352     try {
36353       result = (float)(arg1)->GetHeightForWidth(arg2);
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (Dali::DaliException e) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372
36373   jresult = result;
36374   return jresult;
36375 }
36376
36377
36378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36379   float jresult ;
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   float arg2 ;
36382   float result;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (float)jarg2;
36386   {
36387     try {
36388       result = (float)(arg1)->GetWidthForHeight(arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36404       };
36405     }
36406   }
36407
36408   jresult = result;
36409   return jresult;
36410 }
36411
36412
36413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36414   float jresult ;
36415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36416   Dali::Dimension::Type arg2 ;
36417   float result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (Dali::Dimension::Type)jarg2;
36421   {
36422     try {
36423       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36424     } catch (std::out_of_range& e) {
36425       {
36426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (std::exception& e) {
36429       {
36430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (Dali::DaliException e) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36435       };
36436     } catch (...) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36439       };
36440     }
36441   }
36442
36443   jresult = result;
36444   return jresult;
36445 }
36446
36447
36448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   Dali::Padding *arg2 = 0 ;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   arg2 = (Dali::Padding *)jarg2;
36454   if (!arg2) {
36455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36456     return ;
36457   }
36458   {
36459     try {
36460       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36461     } catch (std::out_of_range& e) {
36462       {
36463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (std::exception& e) {
36466       {
36467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36468       };
36469     } catch (Dali::DaliException e) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36476       };
36477     }
36478   }
36479
36480 }
36481
36482
36483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36485   Dali::Padding *arg2 = 0 ;
36486
36487   arg1 = (Dali::Actor *)jarg1;
36488   arg2 = (Dali::Padding *)jarg2;
36489   if (!arg2) {
36490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36491     return ;
36492   }
36493   {
36494     try {
36495       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36496     } catch (std::out_of_range& e) {
36497       {
36498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36499       };
36500     } catch (std::exception& e) {
36501       {
36502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (Dali::DaliException e) {
36505       {
36506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36511       };
36512     }
36513   }
36514
36515 }
36516
36517
36518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Vector2 *arg2 = 0 ;
36521
36522   arg1 = (Dali::Actor *)jarg1;
36523   arg2 = (Dali::Vector2 *)jarg2;
36524   if (!arg2) {
36525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36526     return ;
36527   }
36528   {
36529     try {
36530       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36531     } catch (std::out_of_range& e) {
36532       {
36533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36534       };
36535     } catch (std::exception& e) {
36536       {
36537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (Dali::DaliException e) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36542       };
36543     } catch (...) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36546       };
36547     }
36548   }
36549
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36554   void * jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   Dali::Vector2 result;
36557
36558   arg1 = (Dali::Actor *)jarg1;
36559   {
36560     try {
36561       result = (arg1)->GetMinimumSize();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (Dali::DaliException e) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36573       };
36574     } catch (...) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36577       };
36578     }
36579   }
36580
36581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36588   Dali::Vector2 *arg2 = 0 ;
36589
36590   arg1 = (Dali::Actor *)jarg1;
36591   arg2 = (Dali::Vector2 *)jarg2;
36592   if (!arg2) {
36593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36594     return ;
36595   }
36596   {
36597     try {
36598       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36599     } catch (std::out_of_range& e) {
36600       {
36601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36602       };
36603     } catch (std::exception& e) {
36604       {
36605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36606       };
36607     } catch (Dali::DaliException e) {
36608       {
36609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36614       };
36615     }
36616   }
36617
36618 }
36619
36620
36621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36622   void * jresult ;
36623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36624   Dali::Vector2 result;
36625
36626   arg1 = (Dali::Actor *)jarg1;
36627   {
36628     try {
36629       result = (arg1)->GetMaximumSize();
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36645       };
36646     }
36647   }
36648
36649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36655   int jresult ;
36656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36657   int result;
36658
36659   arg1 = (Dali::Actor *)jarg1;
36660   {
36661     try {
36662       result = (int)(arg1)->GetHierarchyDepth();
36663       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36664     } catch (std::out_of_range& e) {
36665       {
36666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36667       };
36668     } catch (std::exception& e) {
36669       {
36670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (Dali::DaliException e) {
36673       {
36674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36675       };
36676     } catch (...) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36679       };
36680     }
36681   }
36682
36683   jresult = result;
36684   return jresult;
36685 }
36686
36687
36688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36689   unsigned int jresult ;
36690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36691   Dali::Renderer *arg2 = 0 ;
36692   unsigned int result;
36693
36694   arg1 = (Dali::Actor *)jarg1;
36695   arg2 = (Dali::Renderer *)jarg2;
36696   if (!arg2) {
36697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36698     return 0;
36699   }
36700   {
36701     try {
36702       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36703     } catch (std::out_of_range& e) {
36704       {
36705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36706       };
36707     } catch (std::exception& e) {
36708       {
36709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36710       };
36711     } catch (Dali::DaliException e) {
36712       {
36713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36714       };
36715     } catch (...) {
36716       {
36717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36718       };
36719     }
36720   }
36721
36722   jresult = result;
36723   return jresult;
36724 }
36725
36726
36727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36728   unsigned int jresult ;
36729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36730   unsigned int result;
36731
36732   arg1 = (Dali::Actor *)jarg1;
36733   {
36734     try {
36735       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (Dali::DaliException e) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36747       };
36748     } catch (...) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36751       };
36752     }
36753   }
36754
36755   jresult = result;
36756   return jresult;
36757 }
36758
36759
36760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36761   void * jresult ;
36762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36763   unsigned int arg2 ;
36764   Dali::Renderer result;
36765
36766   arg1 = (Dali::Actor *)jarg1;
36767   arg2 = (unsigned int)jarg2;
36768   {
36769     try {
36770       result = (arg1)->GetRendererAt(arg2);
36771     } catch (std::out_of_range& e) {
36772       {
36773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36774       };
36775     } catch (std::exception& e) {
36776       {
36777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36778       };
36779     } catch (Dali::DaliException e) {
36780       {
36781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36782       };
36783     } catch (...) {
36784       {
36785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36786       };
36787     }
36788   }
36789
36790   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36791   return jresult;
36792 }
36793
36794
36795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36797   Dali::Renderer *arg2 = 0 ;
36798
36799   arg1 = (Dali::Actor *)jarg1;
36800   arg2 = (Dali::Renderer *)jarg2;
36801   if (!arg2) {
36802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36803     return ;
36804   }
36805   {
36806     try {
36807       (arg1)->RemoveRenderer(*arg2);
36808     } catch (std::out_of_range& e) {
36809       {
36810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36811       };
36812     } catch (std::exception& e) {
36813       {
36814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36815       };
36816     } catch (Dali::DaliException e) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36819       };
36820     } catch (...) {
36821       {
36822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36823       };
36824     }
36825   }
36826
36827 }
36828
36829
36830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36832   unsigned int arg2 ;
36833
36834   arg1 = (Dali::Actor *)jarg1;
36835   arg2 = (unsigned int)jarg2;
36836   {
36837     try {
36838       (arg1)->RemoveRenderer(arg2);
36839     } catch (std::out_of_range& e) {
36840       {
36841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36842       };
36843     } catch (std::exception& e) {
36844       {
36845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36846       };
36847     } catch (Dali::DaliException e) {
36848       {
36849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36850       };
36851     } catch (...) {
36852       {
36853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36854       };
36855     }
36856   }
36857
36858 }
36859
36860
36861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36862   void * jresult ;
36863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36864   Dali::Actor::TouchSignalType *result = 0 ;
36865
36866   arg1 = (Dali::Actor *)jarg1;
36867   {
36868     try {
36869       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36870     } catch (std::out_of_range& e) {
36871       {
36872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36873       };
36874     } catch (std::exception& e) {
36875       {
36876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (Dali::DaliException e) {
36879       {
36880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36881       };
36882     } catch (...) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36885       };
36886     }
36887   }
36888
36889   jresult = (void *)result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36895   void * jresult ;
36896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36897   Dali::Actor::TouchDataSignalType *result = 0 ;
36898
36899   arg1 = (Dali::Actor *)jarg1;
36900   {
36901     try {
36902       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (Dali::DaliException e) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36914       };
36915     } catch (...) {
36916       {
36917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36918       };
36919     }
36920   }
36921
36922   jresult = (void *)result;
36923   return jresult;
36924 }
36925
36926
36927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36928   void * jresult ;
36929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36930   Dali::Actor::HoverSignalType *result = 0 ;
36931
36932   arg1 = (Dali::Actor *)jarg1;
36933   {
36934     try {
36935       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (Dali::DaliException e) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36947       };
36948     } catch (...) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36951       };
36952     }
36953   }
36954
36955   jresult = (void *)result;
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36961   void * jresult ;
36962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36963   Dali::Actor::WheelEventSignalType *result = 0 ;
36964
36965   arg1 = (Dali::Actor *)jarg1;
36966   {
36967     try {
36968       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36969     } catch (std::out_of_range& e) {
36970       {
36971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (std::exception& e) {
36974       {
36975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36976       };
36977     } catch (Dali::DaliException e) {
36978       {
36979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36980       };
36981     } catch (...) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36984       };
36985     }
36986   }
36987
36988   jresult = (void *)result;
36989   return jresult;
36990 }
36991
36992
36993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36994   void * jresult ;
36995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36996   Dali::Actor::OnStageSignalType *result = 0 ;
36997
36998   arg1 = (Dali::Actor *)jarg1;
36999   {
37000     try {
37001       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37002     } catch (std::out_of_range& e) {
37003       {
37004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37005       };
37006     } catch (std::exception& e) {
37007       {
37008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (Dali::DaliException e) {
37011       {
37012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37017       };
37018     }
37019   }
37020
37021   jresult = (void *)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37027   void * jresult ;
37028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37029   Dali::Actor::OffStageSignalType *result = 0 ;
37030
37031   arg1 = (Dali::Actor *)jarg1;
37032   {
37033     try {
37034       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (Dali::DaliException e) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37046       };
37047     } catch (...) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37050       };
37051     }
37052   }
37053
37054   jresult = (void *)result;
37055   return jresult;
37056 }
37057
37058
37059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37060   void * jresult ;
37061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37062   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37063
37064   arg1 = (Dali::Actor *)jarg1;
37065   {
37066     try {
37067       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086
37087   jresult = (void *)result;
37088   return jresult;
37089 }
37090
37091
37092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37093   Dali::Actor *arg1 = 0 ;
37094
37095   arg1 = (Dali::Actor *)jarg1;
37096   if (!arg1) {
37097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37098     return ;
37099   }
37100   {
37101     try {
37102       Dali::UnparentAndReset(*arg1);
37103     } catch (std::out_of_range& e) {
37104       {
37105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37106       };
37107     } catch (std::exception& e) {
37108       {
37109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37110       };
37111     } catch (Dali::DaliException e) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37114       };
37115     } catch (...) {
37116       {
37117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37118       };
37119     }
37120   }
37121
37122 }
37123
37124
37125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37126   int jresult ;
37127   int result;
37128
37129   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37130   jresult = (int)result;
37131   return jresult;
37132 }
37133
37134
37135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37136   int jresult ;
37137   int result;
37138
37139   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37140   jresult = (int)result;
37141   return jresult;
37142 }
37143
37144
37145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37146   int jresult ;
37147   int result;
37148
37149   result = (int)Dali::Layer::Property::BEHAVIOR;
37150   jresult = (int)result;
37151   return jresult;
37152 }
37153
37154
37155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37156   void * jresult ;
37157   Dali::Layer::Property *result = 0 ;
37158
37159   {
37160     try {
37161       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37162     } catch (std::out_of_range& e) {
37163       {
37164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37165       };
37166     } catch (std::exception& e) {
37167       {
37168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (Dali::DaliException e) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37173       };
37174     } catch (...) {
37175       {
37176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37177       };
37178     }
37179   }
37180
37181   jresult = (void *)result;
37182   return jresult;
37183 }
37184
37185
37186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37187   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37188
37189   arg1 = (Dali::Layer::Property *)jarg1;
37190   {
37191     try {
37192       delete arg1;
37193     } catch (std::out_of_range& e) {
37194       {
37195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37196       };
37197     } catch (std::exception& e) {
37198       {
37199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37200       };
37201     } catch (Dali::DaliException e) {
37202       {
37203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37204       };
37205     } catch (...) {
37206       {
37207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37208       };
37209     }
37210   }
37211
37212 }
37213
37214
37215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37216   void * jresult ;
37217   Dali::Layer *result = 0 ;
37218
37219   {
37220     try {
37221       result = (Dali::Layer *)new Dali::Layer();
37222     } catch (std::out_of_range& e) {
37223       {
37224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37225       };
37226     } catch (std::exception& e) {
37227       {
37228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37229       };
37230     } catch (Dali::DaliException e) {
37231       {
37232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37233       };
37234     } catch (...) {
37235       {
37236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37237       };
37238     }
37239   }
37240
37241   jresult = (void *)result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37247   void * jresult ;
37248   Dali::Layer result;
37249
37250   {
37251     try {
37252       result = Dali::Layer::New();
37253     } catch (std::out_of_range& e) {
37254       {
37255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (std::exception& e) {
37258       {
37259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37260       };
37261     } catch (Dali::DaliException e) {
37262       {
37263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37264       };
37265     } catch (...) {
37266       {
37267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37268       };
37269     }
37270   }
37271
37272   jresult = new Dali::Layer((const Dali::Layer &)result);
37273   return jresult;
37274 }
37275
37276
37277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37278   void * jresult ;
37279   Dali::BaseHandle arg1 ;
37280   Dali::BaseHandle *argp1 ;
37281   Dali::Layer result;
37282
37283   argp1 = (Dali::BaseHandle *)jarg1;
37284   if (!argp1) {
37285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37286     return 0;
37287   }
37288   arg1 = *argp1;
37289   {
37290     try {
37291       result = Dali::Layer::DownCast(arg1);
37292     } catch (std::out_of_range& e) {
37293       {
37294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37295       };
37296     } catch (std::exception& e) {
37297       {
37298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37299       };
37300     } catch (Dali::DaliException e) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37303       };
37304     } catch (...) {
37305       {
37306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37307       };
37308     }
37309   }
37310
37311   jresult = new Dali::Layer((const Dali::Layer &)result);
37312   return jresult;
37313 }
37314
37315
37316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37317   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37318
37319   arg1 = (Dali::Layer *)jarg1;
37320   {
37321     try {
37322       delete arg1;
37323     } catch (std::out_of_range& e) {
37324       {
37325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37326       };
37327     } catch (std::exception& e) {
37328       {
37329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37330       };
37331     } catch (Dali::DaliException e) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37334       };
37335     } catch (...) {
37336       {
37337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37338       };
37339     }
37340   }
37341
37342 }
37343
37344
37345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37346   void * jresult ;
37347   Dali::Layer *arg1 = 0 ;
37348   Dali::Layer *result = 0 ;
37349
37350   arg1 = (Dali::Layer *)jarg1;
37351   if (!arg1) {
37352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37353     return 0;
37354   }
37355   {
37356     try {
37357       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37358     } catch (std::out_of_range& e) {
37359       {
37360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37361       };
37362     } catch (std::exception& e) {
37363       {
37364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37365       };
37366     } catch (Dali::DaliException e) {
37367       {
37368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37369       };
37370     } catch (...) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37373       };
37374     }
37375   }
37376
37377   jresult = (void *)result;
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37383   void * jresult ;
37384   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37385   Dali::Layer *arg2 = 0 ;
37386   Dali::Layer *result = 0 ;
37387
37388   arg1 = (Dali::Layer *)jarg1;
37389   arg2 = (Dali::Layer *)jarg2;
37390   if (!arg2) {
37391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37392     return 0;
37393   }
37394   {
37395     try {
37396       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37397     } catch (std::out_of_range& e) {
37398       {
37399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37400       };
37401     } catch (std::exception& e) {
37402       {
37403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37404       };
37405     } catch (Dali::DaliException e) {
37406       {
37407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37408       };
37409     } catch (...) {
37410       {
37411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37412       };
37413     }
37414   }
37415
37416   jresult = (void *)result;
37417   return jresult;
37418 }
37419
37420
37421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37422   unsigned int jresult ;
37423   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37424   unsigned int result;
37425
37426   arg1 = (Dali::Layer *)jarg1;
37427   {
37428     try {
37429       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37430     } catch (std::out_of_range& e) {
37431       {
37432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37433       };
37434     } catch (std::exception& e) {
37435       {
37436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37437       };
37438     } catch (Dali::DaliException e) {
37439       {
37440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37441       };
37442     } catch (...) {
37443       {
37444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37445       };
37446     }
37447   }
37448
37449   jresult = result;
37450   return jresult;
37451 }
37452
37453
37454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37455   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37456
37457   arg1 = (Dali::Layer *)jarg1;
37458   {
37459     try {
37460       (arg1)->Raise();
37461     } catch (std::out_of_range& e) {
37462       {
37463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37464       };
37465     } catch (std::exception& e) {
37466       {
37467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37468       };
37469     } catch (Dali::DaliException e) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37472       };
37473     } catch (...) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37476       };
37477     }
37478   }
37479
37480 }
37481
37482
37483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37484   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37485
37486   arg1 = (Dali::Layer *)jarg1;
37487   {
37488     try {
37489       (arg1)->Lower();
37490     } catch (std::out_of_range& e) {
37491       {
37492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37493       };
37494     } catch (std::exception& e) {
37495       {
37496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37497       };
37498     } catch (Dali::DaliException e) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37501       };
37502     } catch (...) {
37503       {
37504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37505       };
37506     }
37507   }
37508
37509 }
37510
37511
37512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37513   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37514   Dali::Layer arg2 ;
37515   Dali::Layer *argp2 ;
37516
37517   arg1 = (Dali::Layer *)jarg1;
37518   argp2 = (Dali::Layer *)jarg2;
37519   if (!argp2) {
37520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37521     return ;
37522   }
37523   arg2 = *argp2;
37524   {
37525     try {
37526       (arg1)->RaiseAbove(arg2);
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37542       };
37543     }
37544   }
37545
37546 }
37547
37548
37549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37550   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37551   Dali::Layer arg2 ;
37552   Dali::Layer *argp2 ;
37553
37554   arg1 = (Dali::Layer *)jarg1;
37555   argp2 = (Dali::Layer *)jarg2;
37556   if (!argp2) {
37557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37558     return ;
37559   }
37560   arg2 = *argp2;
37561   {
37562     try {
37563       (arg1)->LowerBelow(arg2);
37564     } catch (std::out_of_range& e) {
37565       {
37566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37567       };
37568     } catch (std::exception& e) {
37569       {
37570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37571       };
37572     } catch (Dali::DaliException e) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37579       };
37580     }
37581   }
37582
37583 }
37584
37585
37586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37587   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37588
37589   arg1 = (Dali::Layer *)jarg1;
37590   {
37591     try {
37592       (arg1)->RaiseToTop();
37593     } catch (std::out_of_range& e) {
37594       {
37595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37596       };
37597     } catch (std::exception& e) {
37598       {
37599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37600       };
37601     } catch (Dali::DaliException e) {
37602       {
37603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37604       };
37605     } catch (...) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37608       };
37609     }
37610   }
37611
37612 }
37613
37614
37615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37617
37618   arg1 = (Dali::Layer *)jarg1;
37619   {
37620     try {
37621       (arg1)->LowerToBottom();
37622     } catch (std::out_of_range& e) {
37623       {
37624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37625       };
37626     } catch (std::exception& e) {
37627       {
37628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37629       };
37630     } catch (Dali::DaliException e) {
37631       {
37632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37633       };
37634     } catch (...) {
37635       {
37636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37637       };
37638     }
37639   }
37640
37641 }
37642
37643
37644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37645   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37646   Dali::Layer arg2 ;
37647   Dali::Layer *argp2 ;
37648
37649   arg1 = (Dali::Layer *)jarg1;
37650   argp2 = (Dali::Layer *)jarg2;
37651   if (!argp2) {
37652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37653     return ;
37654   }
37655   arg2 = *argp2;
37656   {
37657     try {
37658       (arg1)->MoveAbove(arg2);
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer arg2 ;
37684   Dali::Layer *argp2 ;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   argp2 = (Dali::Layer *)jarg2;
37688   if (!argp2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37690     return ;
37691   }
37692   arg2 = *argp2;
37693   {
37694     try {
37695       (arg1)->MoveBelow(arg2);
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720   Dali::Layer::Behavior arg2 ;
37721
37722   arg1 = (Dali::Layer *)jarg1;
37723   arg2 = (Dali::Layer::Behavior)jarg2;
37724   {
37725     try {
37726       (arg1)->SetBehavior(arg2);
37727     } catch (std::out_of_range& e) {
37728       {
37729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37730       };
37731     } catch (std::exception& e) {
37732       {
37733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37734       };
37735     } catch (Dali::DaliException e) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37738       };
37739     } catch (...) {
37740       {
37741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37742       };
37743     }
37744   }
37745
37746 }
37747
37748
37749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37750   int jresult ;
37751   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37752   Dali::Layer::Behavior result;
37753
37754   arg1 = (Dali::Layer *)jarg1;
37755   {
37756     try {
37757       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37758     } catch (std::out_of_range& e) {
37759       {
37760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (std::exception& e) {
37763       {
37764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37765       };
37766     } catch (Dali::DaliException e) {
37767       {
37768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37769       };
37770     } catch (...) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37773       };
37774     }
37775   }
37776
37777   jresult = (int)result;
37778   return jresult;
37779 }
37780
37781
37782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37784   bool arg2 ;
37785
37786   arg1 = (Dali::Layer *)jarg1;
37787   arg2 = jarg2 ? true : false;
37788   {
37789     try {
37790       (arg1)->SetClipping(arg2);
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (Dali::DaliException e) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37802       };
37803     } catch (...) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37806       };
37807     }
37808   }
37809
37810 }
37811
37812
37813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37814   unsigned int jresult ;
37815   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37816   bool result;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   {
37820     try {
37821       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37822     } catch (std::out_of_range& e) {
37823       {
37824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37825       };
37826     } catch (std::exception& e) {
37827       {
37828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37829       };
37830     } catch (Dali::DaliException e) {
37831       {
37832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37833       };
37834     } catch (...) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37837       };
37838     }
37839   }
37840
37841   jresult = result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37847   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37848   int arg2 ;
37849   int arg3 ;
37850   int arg4 ;
37851   int arg5 ;
37852
37853   arg1 = (Dali::Layer *)jarg1;
37854   arg2 = (int)jarg2;
37855   arg3 = (int)jarg3;
37856   arg4 = (int)jarg4;
37857   arg5 = (int)jarg5;
37858   {
37859     try {
37860       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37861     } catch (std::out_of_range& e) {
37862       {
37863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37864       };
37865     } catch (std::exception& e) {
37866       {
37867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37868       };
37869     } catch (Dali::DaliException e) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37872       };
37873     } catch (...) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37876       };
37877     }
37878   }
37879
37880 }
37881
37882
37883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37884   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37885   Dali::ClippingBox arg2 ;
37886   Dali::ClippingBox *argp2 ;
37887
37888   arg1 = (Dali::Layer *)jarg1;
37889   argp2 = (Dali::ClippingBox *)jarg2;
37890   if (!argp2) {
37891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37892     return ;
37893   }
37894   arg2 = *argp2;
37895   {
37896     try {
37897       (arg1)->SetClippingBox(arg2);
37898     } catch (std::out_of_range& e) {
37899       {
37900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (std::exception& e) {
37903       {
37904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37905       };
37906     } catch (Dali::DaliException e) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37909       };
37910     } catch (...) {
37911       {
37912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37913       };
37914     }
37915   }
37916
37917 }
37918
37919
37920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37921   void * jresult ;
37922   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37923   Dali::ClippingBox result;
37924
37925   arg1 = (Dali::Layer *)jarg1;
37926   {
37927     try {
37928       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37929     } catch (std::out_of_range& e) {
37930       {
37931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (std::exception& e) {
37934       {
37935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37936       };
37937     } catch (Dali::DaliException e) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37944       };
37945     }
37946   }
37947
37948   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37949   return jresult;
37950 }
37951
37952
37953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37954   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37955   bool arg2 ;
37956
37957   arg1 = (Dali::Layer *)jarg1;
37958   arg2 = jarg2 ? true : false;
37959   {
37960     try {
37961       (arg1)->SetDepthTestDisabled(arg2);
37962     } catch (std::out_of_range& e) {
37963       {
37964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37965       };
37966     } catch (std::exception& e) {
37967       {
37968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37969       };
37970     } catch (Dali::DaliException e) {
37971       {
37972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37973       };
37974     } catch (...) {
37975       {
37976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37977       };
37978     }
37979   }
37980
37981 }
37982
37983
37984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37985   unsigned int jresult ;
37986   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37987   bool result;
37988
37989   arg1 = (Dali::Layer *)jarg1;
37990   {
37991     try {
37992       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37993     } catch (std::out_of_range& e) {
37994       {
37995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37996       };
37997     } catch (std::exception& e) {
37998       {
37999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38000       };
38001     } catch (Dali::DaliException e) {
38002       {
38003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38004       };
38005     } catch (...) {
38006       {
38007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38008       };
38009     }
38010   }
38011
38012   jresult = result;
38013   return jresult;
38014 }
38015
38016
38017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38018   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38019   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38020
38021   arg1 = (Dali::Layer *)jarg1;
38022   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38023   {
38024     try {
38025       (arg1)->SetSortFunction(arg2);
38026     } catch (std::out_of_range& e) {
38027       {
38028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38029       };
38030     } catch (std::exception& e) {
38031       {
38032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (Dali::DaliException e) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38041       };
38042     }
38043   }
38044
38045 }
38046
38047
38048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38049   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38050   bool arg2 ;
38051
38052   arg1 = (Dali::Layer *)jarg1;
38053   arg2 = jarg2 ? true : false;
38054   {
38055     try {
38056       (arg1)->SetTouchConsumed(arg2);
38057     } catch (std::out_of_range& e) {
38058       {
38059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38060       };
38061     } catch (std::exception& e) {
38062       {
38063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38064       };
38065     } catch (Dali::DaliException e) {
38066       {
38067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38072       };
38073     }
38074   }
38075
38076 }
38077
38078
38079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38080   unsigned int jresult ;
38081   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38082   bool result;
38083
38084   arg1 = (Dali::Layer *)jarg1;
38085   {
38086     try {
38087       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38088     } catch (std::out_of_range& e) {
38089       {
38090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38091       };
38092     } catch (std::exception& e) {
38093       {
38094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38095       };
38096     } catch (Dali::DaliException e) {
38097       {
38098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38099       };
38100     } catch (...) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38103       };
38104     }
38105   }
38106
38107   jresult = result;
38108   return jresult;
38109 }
38110
38111
38112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38113   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38114   bool arg2 ;
38115
38116   arg1 = (Dali::Layer *)jarg1;
38117   arg2 = jarg2 ? true : false;
38118   {
38119     try {
38120       (arg1)->SetHoverConsumed(arg2);
38121     } catch (std::out_of_range& e) {
38122       {
38123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38124       };
38125     } catch (std::exception& e) {
38126       {
38127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38128       };
38129     } catch (Dali::DaliException e) {
38130       {
38131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38132       };
38133     } catch (...) {
38134       {
38135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38136       };
38137     }
38138   }
38139
38140 }
38141
38142
38143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38144   unsigned int jresult ;
38145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38146   bool result;
38147
38148   arg1 = (Dali::Layer *)jarg1;
38149   {
38150     try {
38151       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38152     } catch (std::out_of_range& e) {
38153       {
38154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38155       };
38156     } catch (std::exception& e) {
38157       {
38158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38159       };
38160     } catch (Dali::DaliException e) {
38161       {
38162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38163       };
38164     } catch (...) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38167       };
38168     }
38169   }
38170
38171   jresult = result;
38172   return jresult;
38173 }
38174
38175
38176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38177   void * jresult ;
38178   Dali::Vector4 *result = 0 ;
38179
38180   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38181   jresult = (void *)result;
38182   return jresult;
38183 }
38184
38185
38186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38187   void * jresult ;
38188   Dali::Vector4 *result = 0 ;
38189
38190   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38197   void * jresult ;
38198   Dali::Stage *result = 0 ;
38199
38200   {
38201     try {
38202       result = (Dali::Stage *)new Dali::Stage();
38203     } catch (std::out_of_range& e) {
38204       {
38205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (std::exception& e) {
38208       {
38209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38210       };
38211     } catch (Dali::DaliException e) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38218       };
38219     }
38220   }
38221
38222   jresult = (void *)result;
38223   return jresult;
38224 }
38225
38226
38227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38228   void * jresult ;
38229   Dali::Stage result;
38230
38231   {
38232     try {
38233       result = Dali::Stage::GetCurrent();
38234     } catch (std::out_of_range& e) {
38235       {
38236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (std::exception& e) {
38239       {
38240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38241       };
38242     } catch (Dali::DaliException e) {
38243       {
38244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38245       };
38246     } catch (...) {
38247       {
38248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38249       };
38250     }
38251   }
38252
38253   jresult = new Dali::Stage((const Dali::Stage &)result);
38254   return jresult;
38255 }
38256
38257
38258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38259   unsigned int jresult ;
38260   bool result;
38261
38262   {
38263     try {
38264       result = (bool)Dali::Stage::IsInstalled();
38265     } catch (std::out_of_range& e) {
38266       {
38267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38268       };
38269     } catch (std::exception& e) {
38270       {
38271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (Dali::DaliException e) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38276       };
38277     } catch (...) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38280       };
38281     }
38282   }
38283
38284   jresult = result;
38285   return jresult;
38286 }
38287
38288
38289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38290   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38291
38292   arg1 = (Dali::Stage *)jarg1;
38293   {
38294     try {
38295       delete arg1;
38296     } catch (std::out_of_range& e) {
38297       {
38298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38299       };
38300     } catch (std::exception& e) {
38301       {
38302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38303       };
38304     } catch (Dali::DaliException e) {
38305       {
38306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38307       };
38308     } catch (...) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38311       };
38312     }
38313   }
38314
38315 }
38316
38317
38318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38319   void * jresult ;
38320   Dali::Stage *arg1 = 0 ;
38321   Dali::Stage *result = 0 ;
38322
38323   arg1 = (Dali::Stage *)jarg1;
38324   if (!arg1) {
38325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38326     return 0;
38327   }
38328   {
38329     try {
38330       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (Dali::DaliException e) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38342       };
38343     } catch (...) {
38344       {
38345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38346       };
38347     }
38348   }
38349
38350   jresult = (void *)result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38356   void * jresult ;
38357   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38358   Dali::Stage *arg2 = 0 ;
38359   Dali::Stage *result = 0 ;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   arg2 = (Dali::Stage *)jarg2;
38363   if (!arg2) {
38364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38365     return 0;
38366   }
38367   {
38368     try {
38369       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38370     } catch (std::out_of_range& e) {
38371       {
38372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38373       };
38374     } catch (std::exception& e) {
38375       {
38376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38377       };
38378     } catch (Dali::DaliException e) {
38379       {
38380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38381       };
38382     } catch (...) {
38383       {
38384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38385       };
38386     }
38387   }
38388
38389   jresult = (void *)result;
38390   return jresult;
38391 }
38392
38393
38394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38395   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38396   Dali::Actor *arg2 = 0 ;
38397
38398   arg1 = (Dali::Stage *)jarg1;
38399   arg2 = (Dali::Actor *)jarg2;
38400   if (!arg2) {
38401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38402     return ;
38403   }
38404   {
38405     try {
38406       (arg1)->Add(*arg2);
38407     } catch (std::out_of_range& e) {
38408       {
38409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38410       };
38411     } catch (std::exception& e) {
38412       {
38413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38414       };
38415     } catch (Dali::DaliException e) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38418       };
38419     } catch (...) {
38420       {
38421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38422       };
38423     }
38424   }
38425
38426 }
38427
38428
38429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38430   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38431   Dali::Actor *arg2 = 0 ;
38432
38433   arg1 = (Dali::Stage *)jarg1;
38434   arg2 = (Dali::Actor *)jarg2;
38435   if (!arg2) {
38436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38437     return ;
38438   }
38439   {
38440     try {
38441       (arg1)->Remove(*arg2);
38442     } catch (std::out_of_range& e) {
38443       {
38444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38445       };
38446     } catch (std::exception& e) {
38447       {
38448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38449       };
38450     } catch (Dali::DaliException e) {
38451       {
38452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38453       };
38454     } catch (...) {
38455       {
38456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38457       };
38458     }
38459   }
38460
38461 }
38462
38463
38464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38465   void * jresult ;
38466   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38467   Dali::Vector2 result;
38468
38469   arg1 = (Dali::Stage *)jarg1;
38470   {
38471     try {
38472       result = ((Dali::Stage const *)arg1)->GetSize();
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38488       };
38489     }
38490   }
38491
38492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38493   return jresult;
38494 }
38495
38496
38497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38498   void * jresult ;
38499   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38500   Dali::RenderTaskList result;
38501
38502   arg1 = (Dali::Stage *)jarg1;
38503   {
38504     try {
38505       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38506     } catch (std::out_of_range& e) {
38507       {
38508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38509       };
38510     } catch (std::exception& e) {
38511       {
38512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38513       };
38514     } catch (Dali::DaliException e) {
38515       {
38516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38517       };
38518     } catch (...) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38521       };
38522     }
38523   }
38524
38525   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38526   return jresult;
38527 }
38528
38529
38530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38531   unsigned int jresult ;
38532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38533   unsigned int result;
38534
38535   arg1 = (Dali::Stage *)jarg1;
38536   {
38537     try {
38538       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = result;
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38564   void * jresult ;
38565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38566   unsigned int arg2 ;
38567   Dali::Layer result;
38568
38569   arg1 = (Dali::Stage *)jarg1;
38570   arg2 = (unsigned int)jarg2;
38571   {
38572     try {
38573       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38574     } catch (std::out_of_range& e) {
38575       {
38576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38577       };
38578     } catch (std::exception& e) {
38579       {
38580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38581       };
38582     } catch (Dali::DaliException e) {
38583       {
38584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38589       };
38590     }
38591   }
38592
38593   jresult = new Dali::Layer((const Dali::Layer &)result);
38594   return jresult;
38595 }
38596
38597
38598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38599   void * jresult ;
38600   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38601   Dali::Layer result;
38602
38603   arg1 = (Dali::Stage *)jarg1;
38604   {
38605     try {
38606       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38607     } catch (std::out_of_range& e) {
38608       {
38609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38610       };
38611     } catch (std::exception& e) {
38612       {
38613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38614       };
38615     } catch (Dali::DaliException e) {
38616       {
38617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38618       };
38619     } catch (...) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38622       };
38623     }
38624   }
38625
38626   jresult = new Dali::Layer((const Dali::Layer &)result);
38627   return jresult;
38628 }
38629
38630
38631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38632   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38633   Dali::Vector4 arg2 ;
38634   Dali::Vector4 *argp2 ;
38635
38636   arg1 = (Dali::Stage *)jarg1;
38637   argp2 = (Dali::Vector4 *)jarg2;
38638   if (!argp2) {
38639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38640     return ;
38641   }
38642   arg2 = *argp2;
38643   {
38644     try {
38645       (arg1)->SetBackgroundColor(arg2);
38646     } catch (std::out_of_range& e) {
38647       {
38648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38649       };
38650     } catch (std::exception& e) {
38651       {
38652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38653       };
38654     } catch (Dali::DaliException e) {
38655       {
38656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38657       };
38658     } catch (...) {
38659       {
38660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38661       };
38662     }
38663   }
38664
38665 }
38666
38667
38668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38669   void * jresult ;
38670   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38671   Dali::Vector4 result;
38672
38673   arg1 = (Dali::Stage *)jarg1;
38674   {
38675     try {
38676       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38677     } catch (std::out_of_range& e) {
38678       {
38679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (std::exception& e) {
38682       {
38683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38684       };
38685     } catch (Dali::DaliException e) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38688       };
38689     } catch (...) {
38690       {
38691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38692       };
38693     }
38694   }
38695
38696   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38697   return jresult;
38698 }
38699
38700
38701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38702   void * jresult ;
38703   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38704   Dali::Vector2 result;
38705
38706   arg1 = (Dali::Stage *)jarg1;
38707   {
38708     try {
38709       result = ((Dali::Stage const *)arg1)->GetDpi();
38710     } catch (std::out_of_range& e) {
38711       {
38712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38713       };
38714     } catch (std::exception& e) {
38715       {
38716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38717       };
38718     } catch (Dali::DaliException e) {
38719       {
38720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38721       };
38722     } catch (...) {
38723       {
38724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38725       };
38726     }
38727   }
38728
38729   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38730   return jresult;
38731 }
38732
38733
38734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38735   void * jresult ;
38736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38737   Dali::ObjectRegistry result;
38738
38739   arg1 = (Dali::Stage *)jarg1;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (Dali::DaliException e) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761
38762   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38768   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38769   float arg2 ;
38770
38771   arg1 = (Dali::Stage *)jarg1;
38772   arg2 = (float)jarg2;
38773   {
38774     try {
38775       (arg1)->KeepRendering(arg2);
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38791       };
38792     }
38793   }
38794
38795 }
38796
38797
38798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38799   void * jresult ;
38800   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38801   Dali::Stage::KeyEventSignalType *result = 0 ;
38802
38803   arg1 = (Dali::Stage *)jarg1;
38804   {
38805     try {
38806       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38807     } catch (std::out_of_range& e) {
38808       {
38809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38810       };
38811     } catch (std::exception& e) {
38812       {
38813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38814       };
38815     } catch (Dali::DaliException e) {
38816       {
38817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38818       };
38819     } catch (...) {
38820       {
38821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38822       };
38823     }
38824   }
38825
38826   jresult = (void *)result;
38827   return jresult;
38828 }
38829
38830
38831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38832   void * jresult ;
38833   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38834   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38835
38836   arg1 = (Dali::Stage *)jarg1;
38837   {
38838     try {
38839       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38840     } catch (std::out_of_range& e) {
38841       {
38842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38843       };
38844     } catch (std::exception& e) {
38845       {
38846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (Dali::DaliException e) {
38849       {
38850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38851       };
38852     } catch (...) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38855       };
38856     }
38857   }
38858
38859   jresult = (void *)result;
38860   return jresult;
38861 }
38862
38863
38864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38865   void * jresult ;
38866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38867   Dali::Stage::TouchSignalType *result = 0 ;
38868
38869   arg1 = (Dali::Stage *)jarg1;
38870   {
38871     try {
38872       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38873     } catch (std::out_of_range& e) {
38874       {
38875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38876       };
38877     } catch (std::exception& e) {
38878       {
38879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (Dali::DaliException e) {
38882       {
38883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38884       };
38885     } catch (...) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38888       };
38889     }
38890   }
38891
38892   jresult = (void *)result;
38893   return jresult;
38894 }
38895
38896
38897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38898   void * jresult ;
38899   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38900   Dali::Stage::WheelEventSignalType *result = 0 ;
38901
38902   arg1 = (Dali::Stage *)jarg1;
38903   {
38904     try {
38905       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38906     } catch (std::out_of_range& e) {
38907       {
38908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38909       };
38910     } catch (std::exception& e) {
38911       {
38912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (Dali::DaliException e) {
38915       {
38916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38921       };
38922     }
38923   }
38924
38925   jresult = (void *)result;
38926   return jresult;
38927 }
38928
38929
38930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38931   void * jresult ;
38932   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38933   Dali::Stage::ContextStatusSignal *result = 0 ;
38934
38935   arg1 = (Dali::Stage *)jarg1;
38936   {
38937     try {
38938       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38939     } catch (std::out_of_range& e) {
38940       {
38941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38942       };
38943     } catch (std::exception& e) {
38944       {
38945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (Dali::DaliException e) {
38948       {
38949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38954       };
38955     }
38956   }
38957
38958   jresult = (void *)result;
38959   return jresult;
38960 }
38961
38962
38963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38964   void * jresult ;
38965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38966   Dali::Stage::ContextStatusSignal *result = 0 ;
38967
38968   arg1 = (Dali::Stage *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38972     } catch (std::out_of_range& e) {
38973       {
38974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (std::exception& e) {
38977       {
38978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (Dali::DaliException e) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38987       };
38988     }
38989   }
38990
38991   jresult = (void *)result;
38992   return jresult;
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38997   void * jresult ;
38998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38999   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39000
39001   arg1 = (Dali::Stage *)jarg1;
39002   {
39003     try {
39004       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39005     } catch (std::out_of_range& e) {
39006       {
39007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39008       };
39009     } catch (std::exception& e) {
39010       {
39011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (Dali::DaliException e) {
39014       {
39015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023
39024   jresult = (void *)result;
39025   return jresult;
39026 }
39027
39028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39029   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39030   Dali::DevelStage::Rendering arg2 ;
39031
39032   arg1 = (Dali::Stage *)jarg1;
39033   arg2 = (Dali::DevelStage::Rendering)jarg2;
39034   {
39035     try {
39036       DevelStage::SetRenderingBehavior(*arg1,arg2);
39037     } catch (std::out_of_range& e) {
39038       {
39039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39040       };
39041     } catch (std::exception& e) {
39042       {
39043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39044       };
39045     } catch (Dali::DaliException e) {
39046       {
39047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39048       };
39049     } catch (...) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39052       };
39053     }
39054   }
39055
39056 }
39057
39058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39059
39060   int jresult ;
39061   int result ;
39062   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39063
39064   arg1 = (Dali::Stage *)jarg1;
39065   {
39066     try {
39067       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
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 = result;
39088   return jresult;
39089 }
39090
39091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39092   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39093
39094   arg1 = (Dali::RelayoutContainer *)jarg1;
39095   {
39096     try {
39097       delete arg1;
39098     } catch (std::out_of_range& e) {
39099       {
39100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39101       };
39102     } catch (std::exception& e) {
39103       {
39104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39105       };
39106     } catch (Dali::DaliException e) {
39107       {
39108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39109       };
39110     } catch (...) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39113       };
39114     }
39115   }
39116
39117 }
39118
39119
39120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39121   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39122   Dali::Actor *arg2 = 0 ;
39123   Dali::Vector2 *arg3 = 0 ;
39124
39125   arg1 = (Dali::RelayoutContainer *)jarg1;
39126   arg2 = (Dali::Actor *)jarg2;
39127   if (!arg2) {
39128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39129     return ;
39130   }
39131   arg3 = (Dali::Vector2 *)jarg3;
39132   if (!arg3) {
39133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39134     return ;
39135   }
39136   {
39137     try {
39138       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39139     } catch (std::out_of_range& e) {
39140       {
39141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39142       };
39143     } catch (std::exception& e) {
39144       {
39145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (Dali::DaliException e) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39154       };
39155     }
39156   }
39157
39158 }
39159
39160
39161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39162   void * jresult ;
39163   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39164   Dali::CustomActor result;
39165
39166   arg1 = (Dali::CustomActorImpl *)jarg1;
39167   {
39168     try {
39169       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39170     } catch (std::out_of_range& e) {
39171       {
39172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39173       };
39174     } catch (std::exception& e) {
39175       {
39176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (Dali::DaliException e) {
39179       {
39180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39181       };
39182     } catch (...) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39185       };
39186     }
39187   }
39188
39189   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39190   return jresult;
39191 }
39192
39193
39194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39195   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39196   int arg2 ;
39197
39198   arg1 = (Dali::CustomActorImpl *)jarg1;
39199   arg2 = (int)jarg2;
39200   {
39201     try {
39202       (arg1)->OnStageConnection(arg2);
39203     } catch (std::out_of_range& e) {
39204       {
39205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39206       };
39207     } catch (std::exception& e) {
39208       {
39209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (Dali::DaliException e) {
39212       {
39213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39214       };
39215     } catch (...) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39218       };
39219     }
39220   }
39221
39222 }
39223
39224
39225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39226   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39227
39228   arg1 = (Dali::CustomActorImpl *)jarg1;
39229   {
39230     try {
39231       (arg1)->OnStageDisconnection();
39232     } catch (std::out_of_range& e) {
39233       {
39234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39235       };
39236     } catch (std::exception& e) {
39237       {
39238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39239       };
39240     } catch (Dali::DaliException e) {
39241       {
39242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39243       };
39244     } catch (...) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39247       };
39248     }
39249   }
39250
39251 }
39252
39253
39254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39255   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39256   Dali::Actor *arg2 = 0 ;
39257
39258   arg1 = (Dali::CustomActorImpl *)jarg1;
39259   arg2 = (Dali::Actor *)jarg2;
39260   if (!arg2) {
39261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39262     return ;
39263   }
39264   {
39265     try {
39266       (arg1)->OnChildAdd(*arg2);
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (Dali::DaliException e) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39282       };
39283     }
39284   }
39285
39286 }
39287
39288
39289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39290   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39291   Dali::Actor *arg2 = 0 ;
39292
39293   arg1 = (Dali::CustomActorImpl *)jarg1;
39294   arg2 = (Dali::Actor *)jarg2;
39295   if (!arg2) {
39296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39297     return ;
39298   }
39299   {
39300     try {
39301       (arg1)->OnChildRemove(*arg2);
39302     } catch (std::out_of_range& e) {
39303       {
39304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39305       };
39306     } catch (std::exception& e) {
39307       {
39308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (Dali::DaliException e) {
39311       {
39312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39313       };
39314     } catch (...) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39317       };
39318     }
39319   }
39320
39321 }
39322
39323
39324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39325   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39326   Dali::Property::Index arg2 ;
39327   Dali::Property::Value arg3 ;
39328   Dali::Property::Value *argp3 ;
39329
39330   arg1 = (Dali::CustomActorImpl *)jarg1;
39331   arg2 = (Dali::Property::Index)jarg2;
39332   argp3 = (Dali::Property::Value *)jarg3;
39333   if (!argp3) {
39334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39335     return ;
39336   }
39337   arg3 = *argp3;
39338   {
39339     try {
39340       (arg1)->OnPropertySet(arg2,arg3);
39341     } catch (std::out_of_range& e) {
39342       {
39343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39344       };
39345     } catch (std::exception& e) {
39346       {
39347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (Dali::DaliException e) {
39350       {
39351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39352       };
39353     } catch (...) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39356       };
39357     }
39358   }
39359
39360 }
39361
39362
39363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39364   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39365   Dali::Vector3 *arg2 = 0 ;
39366
39367   arg1 = (Dali::CustomActorImpl *)jarg1;
39368   arg2 = (Dali::Vector3 *)jarg2;
39369   if (!arg2) {
39370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39371     return ;
39372   }
39373   {
39374     try {
39375       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39376     } catch (std::out_of_range& e) {
39377       {
39378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39379       };
39380     } catch (std::exception& e) {
39381       {
39382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39383       };
39384     } catch (Dali::DaliException e) {
39385       {
39386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39387       };
39388     } catch (...) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39391       };
39392     }
39393   }
39394
39395 }
39396
39397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39398   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39399   Dali::Animation *arg2 = 0 ;
39400   Dali::Vector3 *arg3 = 0 ;
39401
39402   arg1 = (Dali::CustomActorImpl *)jarg1;
39403   arg2 = (Dali::Animation *)jarg2;
39404   if (!arg2) {
39405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39406     return ;
39407   }
39408   arg3 = (Dali::Vector3 *)jarg3;
39409   if (!arg3) {
39410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39411     return ;
39412   }
39413   {
39414     try {
39415       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39416     } catch (std::out_of_range& e) {
39417       {
39418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39419       };
39420     } catch (std::exception& e) {
39421       {
39422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39423       };
39424     } catch (Dali::DaliException e) {
39425       {
39426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39427       };
39428     } catch (...) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39431       };
39432     }
39433   }
39434
39435 }
39436
39437
39438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39439   unsigned int jresult ;
39440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39441   Dali::TouchEvent *arg2 = 0 ;
39442   bool result;
39443
39444   arg1 = (Dali::CustomActorImpl *)jarg1;
39445   arg2 = (Dali::TouchEvent *)jarg2;
39446   if (!arg2) {
39447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39448     return 0;
39449   }
39450   {
39451     try {
39452       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39453     } catch (std::out_of_range& e) {
39454       {
39455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39456       };
39457     } catch (std::exception& e) {
39458       {
39459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39460       };
39461     } catch (Dali::DaliException e) {
39462       {
39463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39464       };
39465     } catch (...) {
39466       {
39467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39468       };
39469     }
39470   }
39471
39472   jresult = result;
39473   return jresult;
39474 }
39475
39476
39477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39478   unsigned int jresult ;
39479   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39480   Dali::HoverEvent *arg2 = 0 ;
39481   bool result;
39482
39483   arg1 = (Dali::CustomActorImpl *)jarg1;
39484   arg2 = (Dali::HoverEvent *)jarg2;
39485   if (!arg2) {
39486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39487     return 0;
39488   }
39489   {
39490     try {
39491       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39492     } catch (std::out_of_range& e) {
39493       {
39494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39495       };
39496     } catch (std::exception& e) {
39497       {
39498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39499       };
39500     } catch (Dali::DaliException e) {
39501       {
39502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39503       };
39504     } catch (...) {
39505       {
39506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39507       };
39508     }
39509   }
39510
39511   jresult = result;
39512   return jresult;
39513 }
39514
39515
39516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39517   unsigned int jresult ;
39518   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39519   Dali::KeyEvent *arg2 = 0 ;
39520   bool result;
39521
39522   arg1 = (Dali::CustomActorImpl *)jarg1;
39523   arg2 = (Dali::KeyEvent *)jarg2;
39524   if (!arg2) {
39525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39526     return 0;
39527   }
39528   {
39529     try {
39530       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39531     } catch (std::out_of_range& e) {
39532       {
39533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39534       };
39535     } catch (std::exception& e) {
39536       {
39537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (Dali::DaliException e) {
39540       {
39541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39542       };
39543     } catch (...) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39546       };
39547     }
39548   }
39549
39550   jresult = result;
39551   return jresult;
39552 }
39553
39554
39555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39556   unsigned int jresult ;
39557   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39558   Dali::WheelEvent *arg2 = 0 ;
39559   bool result;
39560
39561   arg1 = (Dali::CustomActorImpl *)jarg1;
39562   arg2 = (Dali::WheelEvent *)jarg2;
39563   if (!arg2) {
39564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39565     return 0;
39566   }
39567   {
39568     try {
39569       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39570     } catch (std::out_of_range& e) {
39571       {
39572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39573       };
39574     } catch (std::exception& e) {
39575       {
39576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39577       };
39578     } catch (Dali::DaliException e) {
39579       {
39580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39581       };
39582     } catch (...) {
39583       {
39584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39585       };
39586     }
39587   }
39588
39589   jresult = result;
39590   return jresult;
39591 }
39592
39593
39594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39595   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39596   Dali::Vector2 *arg2 = 0 ;
39597   Dali::RelayoutContainer *arg3 = 0 ;
39598
39599   arg1 = (Dali::CustomActorImpl *)jarg1;
39600   arg2 = (Dali::Vector2 *)jarg2;
39601   if (!arg2) {
39602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39603     return ;
39604   }
39605   arg3 = (Dali::RelayoutContainer *)jarg3;
39606   if (!arg3) {
39607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39608     return ;
39609   }
39610   {
39611     try {
39612       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39613     } catch (std::out_of_range& e) {
39614       {
39615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39616       };
39617     } catch (std::exception& e) {
39618       {
39619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39620       };
39621     } catch (Dali::DaliException e) {
39622       {
39623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39624       };
39625     } catch (...) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39628       };
39629     }
39630   }
39631
39632 }
39633
39634
39635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39636   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39637   Dali::ResizePolicy::Type arg2 ;
39638   Dali::Dimension::Type arg3 ;
39639
39640   arg1 = (Dali::CustomActorImpl *)jarg1;
39641   arg2 = (Dali::ResizePolicy::Type)jarg2;
39642   arg3 = (Dali::Dimension::Type)jarg3;
39643   {
39644     try {
39645       (arg1)->OnSetResizePolicy(arg2,arg3);
39646     } catch (std::out_of_range& e) {
39647       {
39648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39649       };
39650     } catch (std::exception& e) {
39651       {
39652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39653       };
39654     } catch (Dali::DaliException e) {
39655       {
39656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39657       };
39658     } catch (...) {
39659       {
39660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39661       };
39662     }
39663   }
39664
39665 }
39666
39667
39668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39669   void * jresult ;
39670   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39671   Dali::Vector3 result;
39672
39673   arg1 = (Dali::CustomActorImpl *)jarg1;
39674   {
39675     try {
39676       result = (arg1)->GetNaturalSize();
39677     } catch (std::out_of_range& e) {
39678       {
39679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39680       };
39681     } catch (std::exception& e) {
39682       {
39683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39684       };
39685     } catch (Dali::DaliException e) {
39686       {
39687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39688       };
39689     } catch (...) {
39690       {
39691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39692       };
39693     }
39694   }
39695
39696   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39697   return jresult;
39698 }
39699
39700
39701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39702   float jresult ;
39703   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39704   Dali::Actor *arg2 = 0 ;
39705   Dali::Dimension::Type arg3 ;
39706   float result;
39707
39708   arg1 = (Dali::CustomActorImpl *)jarg1;
39709   arg2 = (Dali::Actor *)jarg2;
39710   if (!arg2) {
39711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39712     return 0;
39713   }
39714   arg3 = (Dali::Dimension::Type)jarg3;
39715   {
39716     try {
39717       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39718     } catch (std::out_of_range& e) {
39719       {
39720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39721       };
39722     } catch (std::exception& e) {
39723       {
39724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39725       };
39726     } catch (Dali::DaliException e) {
39727       {
39728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39729       };
39730     } catch (...) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39733       };
39734     }
39735   }
39736
39737   jresult = result;
39738   return jresult;
39739 }
39740
39741
39742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39743   float jresult ;
39744   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39745   float arg2 ;
39746   float result;
39747
39748   arg1 = (Dali::CustomActorImpl *)jarg1;
39749   arg2 = (float)jarg2;
39750   {
39751     try {
39752       result = (float)(arg1)->GetHeightForWidth(arg2);
39753     } catch (std::out_of_range& e) {
39754       {
39755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39756       };
39757     } catch (std::exception& e) {
39758       {
39759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (Dali::DaliException e) {
39762       {
39763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39764       };
39765     } catch (...) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39768       };
39769     }
39770   }
39771
39772   jresult = result;
39773   return jresult;
39774 }
39775
39776
39777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39778   float jresult ;
39779   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39780   float arg2 ;
39781   float result;
39782
39783   arg1 = (Dali::CustomActorImpl *)jarg1;
39784   arg2 = (float)jarg2;
39785   {
39786     try {
39787       result = (float)(arg1)->GetWidthForHeight(arg2);
39788     } catch (std::out_of_range& e) {
39789       {
39790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39791       };
39792     } catch (std::exception& e) {
39793       {
39794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (Dali::DaliException e) {
39797       {
39798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39799       };
39800     } catch (...) {
39801       {
39802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39803       };
39804     }
39805   }
39806
39807   jresult = result;
39808   return jresult;
39809 }
39810
39811
39812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39813   unsigned int jresult ;
39814   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39815   Dali::Dimension::Type arg2 ;
39816   bool result;
39817
39818   arg1 = (Dali::CustomActorImpl *)jarg1;
39819   arg2 = (Dali::Dimension::Type)jarg2;
39820   {
39821     try {
39822       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39823     } catch (std::out_of_range& e) {
39824       {
39825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39826       };
39827     } catch (std::exception& e) {
39828       {
39829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39830       };
39831     } catch (Dali::DaliException e) {
39832       {
39833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39834       };
39835     } catch (...) {
39836       {
39837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39838       };
39839     }
39840   }
39841
39842   jresult = result;
39843   return jresult;
39844 }
39845
39846
39847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39848   unsigned int jresult ;
39849   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39850   bool result;
39851
39852   arg1 = (Dali::CustomActorImpl *)jarg1;
39853   {
39854     try {
39855       result = (bool)(arg1)->RelayoutDependentOnChildren();
39856     } catch (std::out_of_range& e) {
39857       {
39858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39859       };
39860     } catch (std::exception& e) {
39861       {
39862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (Dali::DaliException e) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39867       };
39868     } catch (...) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39871       };
39872     }
39873   }
39874
39875   jresult = result;
39876   return jresult;
39877 }
39878
39879
39880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39882   Dali::Dimension::Type arg2 ;
39883
39884   arg1 = (Dali::CustomActorImpl *)jarg1;
39885   arg2 = (Dali::Dimension::Type)jarg2;
39886   {
39887     try {
39888       (arg1)->OnCalculateRelayoutSize(arg2);
39889     } catch (std::out_of_range& e) {
39890       {
39891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39892       };
39893     } catch (std::exception& e) {
39894       {
39895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39896       };
39897     } catch (Dali::DaliException e) {
39898       {
39899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39900       };
39901     } catch (...) {
39902       {
39903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39904       };
39905     }
39906   }
39907
39908 }
39909
39910
39911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39912   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39913   float arg2 ;
39914   Dali::Dimension::Type arg3 ;
39915
39916   arg1 = (Dali::CustomActorImpl *)jarg1;
39917   arg2 = (float)jarg2;
39918   arg3 = (Dali::Dimension::Type)jarg3;
39919   {
39920     try {
39921       (arg1)->OnLayoutNegotiated(arg2,arg3);
39922     } catch (std::out_of_range& e) {
39923       {
39924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39925       };
39926     } catch (std::exception& e) {
39927       {
39928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39929       };
39930     } catch (Dali::DaliException e) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39933       };
39934     } catch (...) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39937       };
39938     }
39939   }
39940
39941 }
39942
39943
39944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39945   unsigned int jresult ;
39946   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39947   bool result;
39948
39949   arg1 = (Dali::CustomActorImpl *)jarg1;
39950   {
39951     try {
39952       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39953     } catch (std::out_of_range& e) {
39954       {
39955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39956       };
39957     } catch (std::exception& e) {
39958       {
39959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (Dali::DaliException e) {
39962       {
39963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39964       };
39965     } catch (...) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39968       };
39969     }
39970   }
39971
39972   jresult = result;
39973   return jresult;
39974 }
39975
39976
39977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39978   unsigned int jresult ;
39979   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39980   bool result;
39981
39982   arg1 = (Dali::CustomActorImpl *)jarg1;
39983   {
39984     try {
39985       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39986     } catch (std::out_of_range& e) {
39987       {
39988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39989       };
39990     } catch (std::exception& e) {
39991       {
39992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (Dali::DaliException e) {
39995       {
39996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39997       };
39998     } catch (...) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40001       };
40002     }
40003   }
40004
40005   jresult = result;
40006   return jresult;
40007 }
40008
40009
40010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40011   unsigned int jresult ;
40012   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40013   bool result;
40014
40015   arg1 = (Dali::CustomActorImpl *)jarg1;
40016   {
40017     try {
40018       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40019     } catch (std::out_of_range& e) {
40020       {
40021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40022       };
40023     } catch (std::exception& e) {
40024       {
40025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (Dali::DaliException e) {
40028       {
40029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40034       };
40035     }
40036   }
40037
40038   jresult = result;
40039   return jresult;
40040 }
40041
40042
40043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40044   unsigned int jresult ;
40045   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40046   bool result;
40047
40048   arg1 = (Dali::CustomActorImpl *)jarg1;
40049   {
40050     try {
40051       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40052     } catch (std::out_of_range& e) {
40053       {
40054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40055       };
40056     } catch (std::exception& e) {
40057       {
40058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40059       };
40060     } catch (Dali::DaliException e) {
40061       {
40062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40063       };
40064     } catch (...) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40067       };
40068     }
40069   }
40070
40071   jresult = result;
40072   return jresult;
40073 }
40074
40075
40076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40077   void * jresult ;
40078   Dali::CustomActor *result = 0 ;
40079
40080   {
40081     try {
40082       result = (Dali::CustomActor *)new Dali::CustomActor();
40083     } catch (std::out_of_range& e) {
40084       {
40085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40086       };
40087     } catch (std::exception& e) {
40088       {
40089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (Dali::DaliException e) {
40092       {
40093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40094       };
40095     } catch (...) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40098       };
40099     }
40100   }
40101
40102   jresult = (void *)result;
40103   return jresult;
40104 }
40105
40106
40107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40108   void * jresult ;
40109   Dali::BaseHandle arg1 ;
40110   Dali::BaseHandle *argp1 ;
40111   Dali::CustomActor result;
40112
40113   argp1 = (Dali::BaseHandle *)jarg1;
40114   if (!argp1) {
40115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40116     return 0;
40117   }
40118   arg1 = *argp1;
40119   {
40120     try {
40121       result = Dali::CustomActor::DownCast(arg1);
40122     } catch (std::out_of_range& e) {
40123       {
40124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40125       };
40126     } catch (std::exception& e) {
40127       {
40128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (Dali::DaliException e) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40133       };
40134     } catch (...) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40137       };
40138     }
40139   }
40140
40141   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40142   return jresult;
40143 }
40144
40145
40146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40147   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40148
40149   arg1 = (Dali::CustomActor *)jarg1;
40150   {
40151     try {
40152       delete arg1;
40153     } catch (std::out_of_range& e) {
40154       {
40155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40156       };
40157     } catch (std::exception& e) {
40158       {
40159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40160       };
40161     } catch (Dali::DaliException e) {
40162       {
40163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40164       };
40165     } catch (...) {
40166       {
40167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40168       };
40169     }
40170   }
40171
40172 }
40173
40174
40175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40176   void * jresult ;
40177   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40178   Dali::CustomActorImpl *result = 0 ;
40179
40180   arg1 = (Dali::CustomActor *)jarg1;
40181   {
40182     try {
40183       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40184     } catch (std::out_of_range& e) {
40185       {
40186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40187       };
40188     } catch (std::exception& e) {
40189       {
40190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (Dali::DaliException e) {
40193       {
40194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40195       };
40196     } catch (...) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40199       };
40200     }
40201   }
40202
40203   jresult = (void *)result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40209   void * jresult ;
40210   Dali::CustomActorImpl *arg1 = 0 ;
40211   Dali::CustomActor *result = 0 ;
40212
40213   arg1 = (Dali::CustomActorImpl *)jarg1;
40214   if (!arg1) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40216     return 0;
40217   }
40218   {
40219     try {
40220       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40221     } catch (std::out_of_range& e) {
40222       {
40223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40224       };
40225     } catch (std::exception& e) {
40226       {
40227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (Dali::DaliException e) {
40230       {
40231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40232       };
40233     } catch (...) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40236       };
40237     }
40238   }
40239
40240   jresult = (void *)result;
40241   return jresult;
40242 }
40243
40244
40245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40246   void * jresult ;
40247   Dali::CustomActor *arg1 = 0 ;
40248   Dali::CustomActor *result = 0 ;
40249
40250   arg1 = (Dali::CustomActor *)jarg1;
40251   if (!arg1) {
40252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40253     return 0;
40254   }
40255   {
40256     try {
40257       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40258     } catch (std::out_of_range& e) {
40259       {
40260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40261       };
40262     } catch (std::exception& e) {
40263       {
40264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40265       };
40266     } catch (Dali::DaliException e) {
40267       {
40268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40269       };
40270     } catch (...) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40273       };
40274     }
40275   }
40276
40277   jresult = (void *)result;
40278   return jresult;
40279 }
40280
40281
40282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40283   void * jresult ;
40284   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40285   Dali::CustomActor *arg2 = 0 ;
40286   Dali::CustomActor *result = 0 ;
40287
40288   arg1 = (Dali::CustomActor *)jarg1;
40289   arg2 = (Dali::CustomActor *)jarg2;
40290   if (!arg2) {
40291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40292     return 0;
40293   }
40294   {
40295     try {
40296       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40297     } catch (std::out_of_range& e) {
40298       {
40299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40300       };
40301     } catch (std::exception& e) {
40302       {
40303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40304       };
40305     } catch (Dali::DaliException e) {
40306       {
40307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40308       };
40309     } catch (...) {
40310       {
40311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40312       };
40313     }
40314   }
40315
40316   jresult = (void *)result;
40317   return jresult;
40318 }
40319
40320
40321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40322   int jresult ;
40323   int result;
40324
40325   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40326   jresult = (int)result;
40327   return jresult;
40328 }
40329
40330
40331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40332   int jresult ;
40333   int result;
40334
40335   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40336   jresult = (int)result;
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40342   int jresult ;
40343   int result;
40344
40345   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40346   jresult = (int)result;
40347   return jresult;
40348 }
40349
40350
40351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40352   int jresult ;
40353   int result;
40354
40355   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40356   jresult = (int)result;
40357   return jresult;
40358 }
40359
40360
40361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40362   int jresult ;
40363   int result;
40364
40365   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40366   jresult = (int)result;
40367   return jresult;
40368 }
40369
40370
40371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40372   int jresult ;
40373   int result;
40374
40375   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40376   jresult = (int)result;
40377   return jresult;
40378 }
40379
40380
40381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40382   int jresult ;
40383   int result;
40384
40385   result = (int)Dali::PanGestureDetector::Property::PANNING;
40386   jresult = (int)result;
40387   return jresult;
40388 }
40389
40390
40391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40392   void * jresult ;
40393   Dali::PanGestureDetector::Property *result = 0 ;
40394
40395   {
40396     try {
40397       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40398     } catch (std::out_of_range& e) {
40399       {
40400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40401       };
40402     } catch (std::exception& e) {
40403       {
40404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40405       };
40406     } catch (Dali::DaliException e) {
40407       {
40408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40409       };
40410     } catch (...) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40413       };
40414     }
40415   }
40416
40417   jresult = (void *)result;
40418   return jresult;
40419 }
40420
40421
40422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40423   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40424
40425   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40426   {
40427     try {
40428       delete arg1;
40429     } catch (std::out_of_range& e) {
40430       {
40431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40432       };
40433     } catch (std::exception& e) {
40434       {
40435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40436       };
40437     } catch (Dali::DaliException e) {
40438       {
40439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40440       };
40441     } catch (...) {
40442       {
40443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40444       };
40445     }
40446   }
40447
40448 }
40449
40450
40451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40452   void * jresult ;
40453   Dali::Radian *result = 0 ;
40454
40455   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40456   jresult = (void *)result;
40457   return jresult;
40458 }
40459
40460
40461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40462   void * jresult ;
40463   Dali::Radian *result = 0 ;
40464
40465   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40466   jresult = (void *)result;
40467   return jresult;
40468 }
40469
40470
40471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40472   void * jresult ;
40473   Dali::Radian *result = 0 ;
40474
40475   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40476   jresult = (void *)result;
40477   return jresult;
40478 }
40479
40480
40481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40482   void * jresult ;
40483   Dali::Radian *result = 0 ;
40484
40485   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40486   jresult = (void *)result;
40487   return jresult;
40488 }
40489
40490
40491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40492   void * jresult ;
40493   Dali::Radian *result = 0 ;
40494
40495   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40496   jresult = (void *)result;
40497   return jresult;
40498 }
40499
40500
40501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40502   void * jresult ;
40503   Dali::Radian *result = 0 ;
40504
40505   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40506   jresult = (void *)result;
40507   return jresult;
40508 }
40509
40510
40511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40512   void * jresult ;
40513   Dali::Radian *result = 0 ;
40514
40515   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40516   jresult = (void *)result;
40517   return jresult;
40518 }
40519
40520
40521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40522   void * jresult ;
40523   Dali::PanGestureDetector *result = 0 ;
40524
40525   {
40526     try {
40527       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40528     } catch (std::out_of_range& e) {
40529       {
40530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40531       };
40532     } catch (std::exception& e) {
40533       {
40534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (Dali::DaliException e) {
40537       {
40538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40539       };
40540     } catch (...) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40543       };
40544     }
40545   }
40546
40547   jresult = (void *)result;
40548   return jresult;
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40553   void * jresult ;
40554   Dali::PanGestureDetector result;
40555
40556   {
40557     try {
40558       result = Dali::PanGestureDetector::New();
40559     } catch (std::out_of_range& e) {
40560       {
40561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40562       };
40563     } catch (std::exception& e) {
40564       {
40565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (Dali::DaliException e) {
40568       {
40569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577
40578   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40579   return jresult;
40580 }
40581
40582
40583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40584   void * jresult ;
40585   Dali::BaseHandle arg1 ;
40586   Dali::BaseHandle *argp1 ;
40587   Dali::PanGestureDetector result;
40588
40589   argp1 = (Dali::BaseHandle *)jarg1;
40590   if (!argp1) {
40591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40592     return 0;
40593   }
40594   arg1 = *argp1;
40595   {
40596     try {
40597       result = Dali::PanGestureDetector::DownCast(arg1);
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (Dali::DaliException e) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40613       };
40614     }
40615   }
40616
40617   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40618   return jresult;
40619 }
40620
40621
40622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40624
40625   arg1 = (Dali::PanGestureDetector *)jarg1;
40626   {
40627     try {
40628       delete arg1;
40629     } catch (std::out_of_range& e) {
40630       {
40631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40632       };
40633     } catch (std::exception& e) {
40634       {
40635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40636       };
40637     } catch (Dali::DaliException e) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40640       };
40641     } catch (...) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40644       };
40645     }
40646   }
40647
40648 }
40649
40650
40651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40652   void * jresult ;
40653   Dali::PanGestureDetector *arg1 = 0 ;
40654   Dali::PanGestureDetector *result = 0 ;
40655
40656   arg1 = (Dali::PanGestureDetector *)jarg1;
40657   if (!arg1) {
40658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40659     return 0;
40660   }
40661   {
40662     try {
40663       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40664     } catch (std::out_of_range& e) {
40665       {
40666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40667       };
40668     } catch (std::exception& e) {
40669       {
40670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40671       };
40672     } catch (Dali::DaliException e) {
40673       {
40674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40675       };
40676     } catch (...) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40679       };
40680     }
40681   }
40682
40683   jresult = (void *)result;
40684   return jresult;
40685 }
40686
40687
40688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40689   void * jresult ;
40690   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40691   Dali::PanGestureDetector *arg2 = 0 ;
40692   Dali::PanGestureDetector *result = 0 ;
40693
40694   arg1 = (Dali::PanGestureDetector *)jarg1;
40695   arg2 = (Dali::PanGestureDetector *)jarg2;
40696   if (!arg2) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40698     return 0;
40699   }
40700   {
40701     try {
40702       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40703     } catch (std::out_of_range& e) {
40704       {
40705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40706       };
40707     } catch (std::exception& e) {
40708       {
40709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40710       };
40711     } catch (Dali::DaliException e) {
40712       {
40713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40714       };
40715     } catch (...) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40718       };
40719     }
40720   }
40721
40722   jresult = (void *)result;
40723   return jresult;
40724 }
40725
40726
40727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40728   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40729   unsigned int arg2 ;
40730
40731   arg1 = (Dali::PanGestureDetector *)jarg1;
40732   arg2 = (unsigned int)jarg2;
40733   {
40734     try {
40735       (arg1)->SetMinimumTouchesRequired(arg2);
40736     } catch (std::out_of_range& e) {
40737       {
40738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40739       };
40740     } catch (std::exception& e) {
40741       {
40742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40743       };
40744     } catch (Dali::DaliException e) {
40745       {
40746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40747       };
40748     } catch (...) {
40749       {
40750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40751       };
40752     }
40753   }
40754
40755 }
40756
40757
40758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40759   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40760   unsigned int arg2 ;
40761
40762   arg1 = (Dali::PanGestureDetector *)jarg1;
40763   arg2 = (unsigned int)jarg2;
40764   {
40765     try {
40766       (arg1)->SetMaximumTouchesRequired(arg2);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40774       };
40775     } catch (Dali::DaliException e) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40778       };
40779     } catch (...) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40782       };
40783     }
40784   }
40785
40786 }
40787
40788
40789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40790   unsigned int jresult ;
40791   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40792   unsigned int result;
40793
40794   arg1 = (Dali::PanGestureDetector *)jarg1;
40795   {
40796     try {
40797       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40798     } catch (std::out_of_range& e) {
40799       {
40800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40801       };
40802     } catch (std::exception& e) {
40803       {
40804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40805       };
40806     } catch (Dali::DaliException e) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40809       };
40810     } catch (...) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40813       };
40814     }
40815   }
40816
40817   jresult = result;
40818   return jresult;
40819 }
40820
40821
40822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40823   unsigned int jresult ;
40824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40825   unsigned int result;
40826
40827   arg1 = (Dali::PanGestureDetector *)jarg1;
40828   {
40829     try {
40830       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40831     } catch (std::out_of_range& e) {
40832       {
40833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (std::exception& e) {
40836       {
40837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40838       };
40839     } catch (Dali::DaliException e) {
40840       {
40841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40842       };
40843     } catch (...) {
40844       {
40845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40846       };
40847     }
40848   }
40849
40850   jresult = result;
40851   return jresult;
40852 }
40853
40854
40855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40856   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40857   Dali::Radian arg2 ;
40858   Dali::Radian arg3 ;
40859   Dali::Radian *argp2 ;
40860   Dali::Radian *argp3 ;
40861
40862   arg1 = (Dali::PanGestureDetector *)jarg1;
40863   argp2 = (Dali::Radian *)jarg2;
40864   if (!argp2) {
40865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40866     return ;
40867   }
40868   arg2 = *argp2;
40869   argp3 = (Dali::Radian *)jarg3;
40870   if (!argp3) {
40871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40872     return ;
40873   }
40874   arg3 = *argp3;
40875   {
40876     try {
40877       (arg1)->AddAngle(arg2,arg3);
40878     } catch (std::out_of_range& e) {
40879       {
40880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40881       };
40882     } catch (std::exception& e) {
40883       {
40884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40885       };
40886     } catch (Dali::DaliException e) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40889       };
40890     } catch (...) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40893       };
40894     }
40895   }
40896
40897 }
40898
40899
40900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40901   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40902   Dali::Radian arg2 ;
40903   Dali::Radian *argp2 ;
40904
40905   arg1 = (Dali::PanGestureDetector *)jarg1;
40906   argp2 = (Dali::Radian *)jarg2;
40907   if (!argp2) {
40908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40909     return ;
40910   }
40911   arg2 = *argp2;
40912   {
40913     try {
40914       (arg1)->AddAngle(arg2);
40915     } catch (std::out_of_range& e) {
40916       {
40917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40918       };
40919     } catch (std::exception& e) {
40920       {
40921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40922       };
40923     } catch (Dali::DaliException e) {
40924       {
40925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40926       };
40927     } catch (...) {
40928       {
40929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40930       };
40931     }
40932   }
40933
40934 }
40935
40936
40937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40938   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40939   Dali::Radian arg2 ;
40940   Dali::Radian arg3 ;
40941   Dali::Radian *argp2 ;
40942   Dali::Radian *argp3 ;
40943
40944   arg1 = (Dali::PanGestureDetector *)jarg1;
40945   argp2 = (Dali::Radian *)jarg2;
40946   if (!argp2) {
40947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40948     return ;
40949   }
40950   arg2 = *argp2;
40951   argp3 = (Dali::Radian *)jarg3;
40952   if (!argp3) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40954     return ;
40955   }
40956   arg3 = *argp3;
40957   {
40958     try {
40959       (arg1)->AddDirection(arg2,arg3);
40960     } catch (std::out_of_range& e) {
40961       {
40962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40963       };
40964     } catch (std::exception& e) {
40965       {
40966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (Dali::DaliException e) {
40969       {
40970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40971       };
40972     } catch (...) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40975       };
40976     }
40977   }
40978
40979 }
40980
40981
40982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40983   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40984   Dali::Radian arg2 ;
40985   Dali::Radian *argp2 ;
40986
40987   arg1 = (Dali::PanGestureDetector *)jarg1;
40988   argp2 = (Dali::Radian *)jarg2;
40989   if (!argp2) {
40990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40991     return ;
40992   }
40993   arg2 = *argp2;
40994   {
40995     try {
40996       (arg1)->AddDirection(arg2);
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (Dali::DaliException e) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41012       };
41013     }
41014   }
41015
41016 }
41017
41018
41019 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41020   unsigned long jresult ;
41021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41022   size_t result;
41023
41024   arg1 = (Dali::PanGestureDetector *)jarg1;
41025   {
41026     try {
41027       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41028     } catch (std::out_of_range& e) {
41029       {
41030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41031       };
41032     } catch (std::exception& e) {
41033       {
41034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (Dali::DaliException e) {
41037       {
41038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41039       };
41040     } catch (...) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41043       };
41044     }
41045   }
41046
41047   jresult = (unsigned long)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41053   void * jresult ;
41054   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41055   size_t arg2 ;
41056   Dali::PanGestureDetector::AngleThresholdPair result;
41057
41058   arg1 = (Dali::PanGestureDetector *)jarg1;
41059   arg2 = (size_t)jarg2;
41060   {
41061     try {
41062       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (Dali::DaliException e) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41074       };
41075     } catch (...) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41078       };
41079     }
41080   }
41081
41082   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41083   return jresult;
41084 }
41085
41086
41087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41088   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41089
41090   arg1 = (Dali::PanGestureDetector *)jarg1;
41091   {
41092     try {
41093       (arg1)->ClearAngles();
41094     } catch (std::out_of_range& e) {
41095       {
41096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41097       };
41098     } catch (std::exception& e) {
41099       {
41100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41101       };
41102     } catch (Dali::DaliException e) {
41103       {
41104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41105       };
41106     } catch (...) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41109       };
41110     }
41111   }
41112
41113 }
41114
41115
41116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41118   Dali::Radian arg2 ;
41119   Dali::Radian *argp2 ;
41120
41121   arg1 = (Dali::PanGestureDetector *)jarg1;
41122   argp2 = (Dali::Radian *)jarg2;
41123   if (!argp2) {
41124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41125     return ;
41126   }
41127   arg2 = *argp2;
41128   {
41129     try {
41130       (arg1)->RemoveAngle(arg2);
41131     } catch (std::out_of_range& e) {
41132       {
41133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41134       };
41135     } catch (std::exception& e) {
41136       {
41137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41138       };
41139     } catch (Dali::DaliException e) {
41140       {
41141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41142       };
41143     } catch (...) {
41144       {
41145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41146       };
41147     }
41148   }
41149
41150 }
41151
41152
41153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41154   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41155   Dali::Radian arg2 ;
41156   Dali::Radian *argp2 ;
41157
41158   arg1 = (Dali::PanGestureDetector *)jarg1;
41159   argp2 = (Dali::Radian *)jarg2;
41160   if (!argp2) {
41161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41162     return ;
41163   }
41164   arg2 = *argp2;
41165   {
41166     try {
41167       (arg1)->RemoveDirection(arg2);
41168     } catch (std::out_of_range& e) {
41169       {
41170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (std::exception& e) {
41173       {
41174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (Dali::DaliException e) {
41177       {
41178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41179       };
41180     } catch (...) {
41181       {
41182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41183       };
41184     }
41185   }
41186
41187 }
41188
41189
41190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41191   void * jresult ;
41192   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41193   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41194
41195   arg1 = (Dali::PanGestureDetector *)jarg1;
41196   {
41197     try {
41198       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41199     } catch (std::out_of_range& e) {
41200       {
41201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41202       };
41203     } catch (std::exception& e) {
41204       {
41205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (Dali::DaliException e) {
41208       {
41209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41210       };
41211     } catch (...) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41214       };
41215     }
41216   }
41217
41218   jresult = (void *)result;
41219   return jresult;
41220 }
41221
41222
41223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41224   Dali::PanGesture *arg1 = 0 ;
41225
41226   arg1 = (Dali::PanGesture *)jarg1;
41227   if (!arg1) {
41228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41229     return ;
41230   }
41231   {
41232     try {
41233       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41234     } catch (std::out_of_range& e) {
41235       {
41236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41237       };
41238     } catch (std::exception& e) {
41239       {
41240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41241       };
41242     } catch (Dali::DaliException e) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41245       };
41246     } catch (...) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41249       };
41250     }
41251   }
41252
41253 }
41254
41255
41256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41257   void * jresult ;
41258   Dali::PanGesture *result = 0 ;
41259
41260   {
41261     try {
41262       result = (Dali::PanGesture *)new Dali::PanGesture();
41263     } catch (std::out_of_range& e) {
41264       {
41265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41266       };
41267     } catch (std::exception& e) {
41268       {
41269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (Dali::DaliException e) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41274       };
41275     } catch (...) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41278       };
41279     }
41280   }
41281
41282   jresult = (void *)result;
41283   return jresult;
41284 }
41285
41286
41287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41288   void * jresult ;
41289   Dali::Gesture::State arg1 ;
41290   Dali::PanGesture *result = 0 ;
41291
41292   arg1 = (Dali::Gesture::State)jarg1;
41293   {
41294     try {
41295       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41296     } catch (std::out_of_range& e) {
41297       {
41298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41299       };
41300     } catch (std::exception& e) {
41301       {
41302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (Dali::DaliException e) {
41305       {
41306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41321   void * jresult ;
41322   Dali::PanGesture *arg1 = 0 ;
41323   Dali::PanGesture *result = 0 ;
41324
41325   arg1 = (Dali::PanGesture *)jarg1;
41326   if (!arg1) {
41327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41328     return 0;
41329   }
41330   {
41331     try {
41332       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41333     } catch (std::out_of_range& e) {
41334       {
41335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41336       };
41337     } catch (std::exception& e) {
41338       {
41339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (Dali::DaliException e) {
41342       {
41343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41344       };
41345     } catch (...) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41348       };
41349     }
41350   }
41351
41352   jresult = (void *)result;
41353   return jresult;
41354 }
41355
41356
41357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41358   void * jresult ;
41359   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41360   Dali::PanGesture *arg2 = 0 ;
41361   Dali::PanGesture *result = 0 ;
41362
41363   arg1 = (Dali::PanGesture *)jarg1;
41364   arg2 = (Dali::PanGesture *)jarg2;
41365   if (!arg2) {
41366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41367     return 0;
41368   }
41369   {
41370     try {
41371       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41372     } catch (std::out_of_range& e) {
41373       {
41374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (std::exception& e) {
41377       {
41378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (Dali::DaliException e) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41383       };
41384     } catch (...) {
41385       {
41386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41387       };
41388     }
41389   }
41390
41391   jresult = (void *)result;
41392   return jresult;
41393 }
41394
41395
41396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41397   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41398
41399   arg1 = (Dali::PanGesture *)jarg1;
41400   {
41401     try {
41402       delete arg1;
41403     } catch (std::out_of_range& e) {
41404       {
41405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41406       };
41407     } catch (std::exception& e) {
41408       {
41409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (Dali::DaliException e) {
41412       {
41413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41414       };
41415     } catch (...) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41418       };
41419     }
41420   }
41421
41422 }
41423
41424
41425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41426   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41427   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41428
41429   arg1 = (Dali::PanGesture *)jarg1;
41430   arg2 = (Dali::Vector2 *)jarg2;
41431   if (arg1) (arg1)->velocity = *arg2;
41432 }
41433
41434
41435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41436   void * jresult ;
41437   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41438   Dali::Vector2 *result = 0 ;
41439
41440   arg1 = (Dali::PanGesture *)jarg1;
41441   result = (Dali::Vector2 *)& ((arg1)->velocity);
41442   jresult = (void *)result;
41443   return jresult;
41444 }
41445
41446
41447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41448   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41449   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41450
41451   arg1 = (Dali::PanGesture *)jarg1;
41452   arg2 = (Dali::Vector2 *)jarg2;
41453   if (arg1) (arg1)->displacement = *arg2;
41454 }
41455
41456
41457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41458   void * jresult ;
41459   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41460   Dali::Vector2 *result = 0 ;
41461
41462   arg1 = (Dali::PanGesture *)jarg1;
41463   result = (Dali::Vector2 *)& ((arg1)->displacement);
41464   jresult = (void *)result;
41465   return jresult;
41466 }
41467
41468
41469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41470   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41471   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41472
41473   arg1 = (Dali::PanGesture *)jarg1;
41474   arg2 = (Dali::Vector2 *)jarg2;
41475   if (arg1) (arg1)->position = *arg2;
41476 }
41477
41478
41479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41480   void * jresult ;
41481   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41482   Dali::Vector2 *result = 0 ;
41483
41484   arg1 = (Dali::PanGesture *)jarg1;
41485   result = (Dali::Vector2 *)& ((arg1)->position);
41486   jresult = (void *)result;
41487   return jresult;
41488 }
41489
41490
41491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41492   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41493   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41494
41495   arg1 = (Dali::PanGesture *)jarg1;
41496   arg2 = (Dali::Vector2 *)jarg2;
41497   if (arg1) (arg1)->screenVelocity = *arg2;
41498 }
41499
41500
41501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41502   void * jresult ;
41503   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41504   Dali::Vector2 *result = 0 ;
41505
41506   arg1 = (Dali::PanGesture *)jarg1;
41507   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41508   jresult = (void *)result;
41509   return jresult;
41510 }
41511
41512
41513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41514   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41515   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41516
41517   arg1 = (Dali::PanGesture *)jarg1;
41518   arg2 = (Dali::Vector2 *)jarg2;
41519   if (arg1) (arg1)->screenDisplacement = *arg2;
41520 }
41521
41522
41523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41524   void * jresult ;
41525   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41526   Dali::Vector2 *result = 0 ;
41527
41528   arg1 = (Dali::PanGesture *)jarg1;
41529   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41530   jresult = (void *)result;
41531   return jresult;
41532 }
41533
41534
41535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41536   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41537   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41538
41539   arg1 = (Dali::PanGesture *)jarg1;
41540   arg2 = (Dali::Vector2 *)jarg2;
41541   if (arg1) (arg1)->screenPosition = *arg2;
41542 }
41543
41544
41545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41546   void * jresult ;
41547   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41548   Dali::Vector2 *result = 0 ;
41549
41550   arg1 = (Dali::PanGesture *)jarg1;
41551   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41552   jresult = (void *)result;
41553   return jresult;
41554 }
41555
41556
41557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41558   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41559   unsigned int arg2 ;
41560
41561   arg1 = (Dali::PanGesture *)jarg1;
41562   arg2 = (unsigned int)jarg2;
41563   if (arg1) (arg1)->numberOfTouches = arg2;
41564 }
41565
41566
41567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41568   unsigned int jresult ;
41569   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41570   unsigned int result;
41571
41572   arg1 = (Dali::PanGesture *)jarg1;
41573   result = (unsigned int) ((arg1)->numberOfTouches);
41574   jresult = result;
41575   return jresult;
41576 }
41577
41578
41579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41580   float jresult ;
41581   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41582   float result;
41583
41584   arg1 = (Dali::PanGesture *)jarg1;
41585   {
41586     try {
41587       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41588     } catch (std::out_of_range& e) {
41589       {
41590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41591       };
41592     } catch (std::exception& e) {
41593       {
41594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (Dali::DaliException e) {
41597       {
41598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41599       };
41600     } catch (...) {
41601       {
41602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41603       };
41604     }
41605   }
41606
41607   jresult = result;
41608   return jresult;
41609 }
41610
41611
41612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41613   float jresult ;
41614   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41615   float result;
41616
41617   arg1 = (Dali::PanGesture *)jarg1;
41618   {
41619     try {
41620       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41621     } catch (std::out_of_range& e) {
41622       {
41623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (std::exception& e) {
41626       {
41627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (Dali::DaliException e) {
41630       {
41631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41632       };
41633     } catch (...) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41636       };
41637     }
41638   }
41639
41640   jresult = result;
41641   return jresult;
41642 }
41643
41644
41645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41646   float jresult ;
41647   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41648   float result;
41649
41650   arg1 = (Dali::PanGesture *)jarg1;
41651   {
41652     try {
41653       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41654     } catch (std::out_of_range& e) {
41655       {
41656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41657       };
41658     } catch (std::exception& e) {
41659       {
41660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41661       };
41662     } catch (Dali::DaliException e) {
41663       {
41664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41665       };
41666     } catch (...) {
41667       {
41668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41669       };
41670     }
41671   }
41672
41673   jresult = result;
41674   return jresult;
41675 }
41676
41677
41678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41679   float jresult ;
41680   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41681   float result;
41682
41683   arg1 = (Dali::PanGesture *)jarg1;
41684   {
41685     try {
41686       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41687     } catch (std::out_of_range& e) {
41688       {
41689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41690       };
41691     } catch (std::exception& e) {
41692       {
41693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41694       };
41695     } catch (Dali::DaliException e) {
41696       {
41697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41698       };
41699     } catch (...) {
41700       {
41701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41702       };
41703     }
41704   }
41705
41706   jresult = result;
41707   return jresult;
41708 }
41709
41710
41711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41712   void * jresult ;
41713   Dali::PinchGestureDetector *result = 0 ;
41714
41715   {
41716     try {
41717       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41718     } catch (std::out_of_range& e) {
41719       {
41720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41721       };
41722     } catch (std::exception& e) {
41723       {
41724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (Dali::DaliException e) {
41727       {
41728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41729       };
41730     } catch (...) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41733       };
41734     }
41735   }
41736
41737   jresult = (void *)result;
41738   return jresult;
41739 }
41740
41741
41742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41743   void * jresult ;
41744   Dali::PinchGestureDetector result;
41745
41746   {
41747     try {
41748       result = Dali::PinchGestureDetector::New();
41749     } catch (std::out_of_range& e) {
41750       {
41751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41752       };
41753     } catch (std::exception& e) {
41754       {
41755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (Dali::DaliException e) {
41758       {
41759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767
41768   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41769   return jresult;
41770 }
41771
41772
41773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41774   void * jresult ;
41775   Dali::BaseHandle arg1 ;
41776   Dali::BaseHandle *argp1 ;
41777   Dali::PinchGestureDetector result;
41778
41779   argp1 = (Dali::BaseHandle *)jarg1;
41780   if (!argp1) {
41781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41782     return 0;
41783   }
41784   arg1 = *argp1;
41785   {
41786     try {
41787       result = Dali::PinchGestureDetector::DownCast(arg1);
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (Dali::DaliException e) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41799       };
41800     } catch (...) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41803       };
41804     }
41805   }
41806
41807   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41813   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41814
41815   arg1 = (Dali::PinchGestureDetector *)jarg1;
41816   {
41817     try {
41818       delete arg1;
41819     } catch (std::out_of_range& e) {
41820       {
41821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41822       };
41823     } catch (std::exception& e) {
41824       {
41825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41826       };
41827     } catch (Dali::DaliException e) {
41828       {
41829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41830       };
41831     } catch (...) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41834       };
41835     }
41836   }
41837
41838 }
41839
41840
41841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41842   void * jresult ;
41843   Dali::PinchGestureDetector *arg1 = 0 ;
41844   Dali::PinchGestureDetector *result = 0 ;
41845
41846   arg1 = (Dali::PinchGestureDetector *)jarg1;
41847   if (!arg1) {
41848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41849     return 0;
41850   }
41851   {
41852     try {
41853       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41854     } catch (std::out_of_range& e) {
41855       {
41856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (std::exception& e) {
41859       {
41860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (Dali::DaliException e) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41865       };
41866     } catch (...) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41869       };
41870     }
41871   }
41872
41873   jresult = (void *)result;
41874   return jresult;
41875 }
41876
41877
41878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41879   void * jresult ;
41880   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41881   Dali::PinchGestureDetector *arg2 = 0 ;
41882   Dali::PinchGestureDetector *result = 0 ;
41883
41884   arg1 = (Dali::PinchGestureDetector *)jarg1;
41885   arg2 = (Dali::PinchGestureDetector *)jarg2;
41886   if (!arg2) {
41887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41888     return 0;
41889   }
41890   {
41891     try {
41892       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (Dali::DaliException e) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41904       };
41905     } catch (...) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41908       };
41909     }
41910   }
41911
41912   jresult = (void *)result;
41913   return jresult;
41914 }
41915
41916
41917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41918   void * jresult ;
41919   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41920   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41921
41922   arg1 = (Dali::PinchGestureDetector *)jarg1;
41923   {
41924     try {
41925       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41926     } catch (std::out_of_range& e) {
41927       {
41928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41929       };
41930     } catch (std::exception& e) {
41931       {
41932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (Dali::DaliException e) {
41935       {
41936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41937       };
41938     } catch (...) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41941       };
41942     }
41943   }
41944
41945   jresult = (void *)result;
41946   return jresult;
41947 }
41948
41949
41950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41951   void * jresult ;
41952   Dali::Gesture::State arg1 ;
41953   Dali::PinchGesture *result = 0 ;
41954
41955   arg1 = (Dali::Gesture::State)jarg1;
41956   {
41957     try {
41958       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41959     } catch (std::out_of_range& e) {
41960       {
41961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (std::exception& e) {
41964       {
41965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41966       };
41967     } catch (Dali::DaliException e) {
41968       {
41969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41970       };
41971     } catch (...) {
41972       {
41973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41974       };
41975     }
41976   }
41977
41978   jresult = (void *)result;
41979   return jresult;
41980 }
41981
41982
41983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41984   void * jresult ;
41985   Dali::PinchGesture *arg1 = 0 ;
41986   Dali::PinchGesture *result = 0 ;
41987
41988   arg1 = (Dali::PinchGesture *)jarg1;
41989   if (!arg1) {
41990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41991     return 0;
41992   }
41993   {
41994     try {
41995       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41996     } catch (std::out_of_range& e) {
41997       {
41998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41999       };
42000     } catch (std::exception& e) {
42001       {
42002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42003       };
42004     } catch (Dali::DaliException e) {
42005       {
42006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42007       };
42008     } catch (...) {
42009       {
42010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42011       };
42012     }
42013   }
42014
42015   jresult = (void *)result;
42016   return jresult;
42017 }
42018
42019
42020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42021   void * jresult ;
42022   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42023   Dali::PinchGesture *arg2 = 0 ;
42024   Dali::PinchGesture *result = 0 ;
42025
42026   arg1 = (Dali::PinchGesture *)jarg1;
42027   arg2 = (Dali::PinchGesture *)jarg2;
42028   if (!arg2) {
42029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42030     return 0;
42031   }
42032   {
42033     try {
42034       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42035     } catch (std::out_of_range& e) {
42036       {
42037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42038       };
42039     } catch (std::exception& e) {
42040       {
42041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42042       };
42043     } catch (Dali::DaliException e) {
42044       {
42045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42046       };
42047     } catch (...) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42050       };
42051     }
42052   }
42053
42054   jresult = (void *)result;
42055   return jresult;
42056 }
42057
42058
42059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42060   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42061
42062   arg1 = (Dali::PinchGesture *)jarg1;
42063   {
42064     try {
42065       delete arg1;
42066     } catch (std::out_of_range& e) {
42067       {
42068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42069       };
42070     } catch (std::exception& e) {
42071       {
42072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42073       };
42074     } catch (Dali::DaliException e) {
42075       {
42076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42077       };
42078     } catch (...) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42081       };
42082     }
42083   }
42084
42085 }
42086
42087
42088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42089   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42090   float arg2 ;
42091
42092   arg1 = (Dali::PinchGesture *)jarg1;
42093   arg2 = (float)jarg2;
42094   if (arg1) (arg1)->scale = arg2;
42095 }
42096
42097
42098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42099   float jresult ;
42100   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42101   float result;
42102
42103   arg1 = (Dali::PinchGesture *)jarg1;
42104   result = (float) ((arg1)->scale);
42105   jresult = result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42111   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42112   float arg2 ;
42113
42114   arg1 = (Dali::PinchGesture *)jarg1;
42115   arg2 = (float)jarg2;
42116   if (arg1) (arg1)->speed = arg2;
42117 }
42118
42119
42120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42121   float jresult ;
42122   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42123   float result;
42124
42125   arg1 = (Dali::PinchGesture *)jarg1;
42126   result = (float) ((arg1)->speed);
42127   jresult = result;
42128   return jresult;
42129 }
42130
42131
42132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42133   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42134   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42135
42136   arg1 = (Dali::PinchGesture *)jarg1;
42137   arg2 = (Dali::Vector2 *)jarg2;
42138   if (arg1) (arg1)->screenCenterPoint = *arg2;
42139 }
42140
42141
42142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42143   void * jresult ;
42144   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42145   Dali::Vector2 *result = 0 ;
42146
42147   arg1 = (Dali::PinchGesture *)jarg1;
42148   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42149   jresult = (void *)result;
42150   return jresult;
42151 }
42152
42153
42154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42155   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42156   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42157
42158   arg1 = (Dali::PinchGesture *)jarg1;
42159   arg2 = (Dali::Vector2 *)jarg2;
42160   if (arg1) (arg1)->localCenterPoint = *arg2;
42161 }
42162
42163
42164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42165   void * jresult ;
42166   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42167   Dali::Vector2 *result = 0 ;
42168
42169   arg1 = (Dali::PinchGesture *)jarg1;
42170   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42171   jresult = (void *)result;
42172   return jresult;
42173 }
42174
42175
42176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42177   void * jresult ;
42178   Dali::TapGestureDetector *result = 0 ;
42179
42180   {
42181     try {
42182       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42183     } catch (std::out_of_range& e) {
42184       {
42185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42186       };
42187     } catch (std::exception& e) {
42188       {
42189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (Dali::DaliException e) {
42192       {
42193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42194       };
42195     } catch (...) {
42196       {
42197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42198       };
42199     }
42200   }
42201
42202   jresult = (void *)result;
42203   return jresult;
42204 }
42205
42206
42207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42208   void * jresult ;
42209   Dali::TapGestureDetector result;
42210
42211   {
42212     try {
42213       result = Dali::TapGestureDetector::New();
42214     } catch (std::out_of_range& e) {
42215       {
42216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42217       };
42218     } catch (std::exception& e) {
42219       {
42220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (Dali::DaliException e) {
42223       {
42224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42225       };
42226     } catch (...) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42229       };
42230     }
42231   }
42232
42233   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42239   void * jresult ;
42240   unsigned int arg1 ;
42241   Dali::TapGestureDetector result;
42242
42243   arg1 = (unsigned int)jarg1;
42244   {
42245     try {
42246       result = Dali::TapGestureDetector::New(arg1);
42247     } catch (std::out_of_range& e) {
42248       {
42249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42250       };
42251     } catch (std::exception& e) {
42252       {
42253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42254       };
42255     } catch (Dali::DaliException e) {
42256       {
42257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42258       };
42259     } catch (...) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42262       };
42263     }
42264   }
42265
42266   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42267   return jresult;
42268 }
42269
42270
42271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42272   void * jresult ;
42273   Dali::BaseHandle arg1 ;
42274   Dali::BaseHandle *argp1 ;
42275   Dali::TapGestureDetector result;
42276
42277   argp1 = (Dali::BaseHandle *)jarg1;
42278   if (!argp1) {
42279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42280     return 0;
42281   }
42282   arg1 = *argp1;
42283   {
42284     try {
42285       result = Dali::TapGestureDetector::DownCast(arg1);
42286     } catch (std::out_of_range& e) {
42287       {
42288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42289       };
42290     } catch (std::exception& e) {
42291       {
42292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (Dali::DaliException e) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42297       };
42298     } catch (...) {
42299       {
42300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42301       };
42302     }
42303   }
42304
42305   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42306   return jresult;
42307 }
42308
42309
42310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42311   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42312
42313   arg1 = (Dali::TapGestureDetector *)jarg1;
42314   {
42315     try {
42316       delete arg1;
42317     } catch (std::out_of_range& e) {
42318       {
42319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42320       };
42321     } catch (std::exception& e) {
42322       {
42323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42324       };
42325     } catch (Dali::DaliException e) {
42326       {
42327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42328       };
42329     } catch (...) {
42330       {
42331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42332       };
42333     }
42334   }
42335
42336 }
42337
42338
42339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42340   void * jresult ;
42341   Dali::TapGestureDetector *arg1 = 0 ;
42342   Dali::TapGestureDetector *result = 0 ;
42343
42344   arg1 = (Dali::TapGestureDetector *)jarg1;
42345   if (!arg1) {
42346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42347     return 0;
42348   }
42349   {
42350     try {
42351       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42352     } catch (std::out_of_range& e) {
42353       {
42354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (std::exception& e) {
42357       {
42358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (Dali::DaliException e) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42363       };
42364     } catch (...) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42367       };
42368     }
42369   }
42370
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42377   void * jresult ;
42378   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42379   Dali::TapGestureDetector *arg2 = 0 ;
42380   Dali::TapGestureDetector *result = 0 ;
42381
42382   arg1 = (Dali::TapGestureDetector *)jarg1;
42383   arg2 = (Dali::TapGestureDetector *)jarg2;
42384   if (!arg2) {
42385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42386     return 0;
42387   }
42388   {
42389     try {
42390       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42391     } catch (std::out_of_range& e) {
42392       {
42393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42394       };
42395     } catch (std::exception& e) {
42396       {
42397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42398       };
42399     } catch (Dali::DaliException e) {
42400       {
42401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42402       };
42403     } catch (...) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42406       };
42407     }
42408   }
42409
42410   jresult = (void *)result;
42411   return jresult;
42412 }
42413
42414
42415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42416   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42417   unsigned int arg2 ;
42418
42419   arg1 = (Dali::TapGestureDetector *)jarg1;
42420   arg2 = (unsigned int)jarg2;
42421   {
42422     try {
42423       (arg1)->SetMinimumTapsRequired(arg2);
42424     } catch (std::out_of_range& e) {
42425       {
42426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42427       };
42428     } catch (std::exception& e) {
42429       {
42430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42431       };
42432     } catch (Dali::DaliException e) {
42433       {
42434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42435       };
42436     } catch (...) {
42437       {
42438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42439       };
42440     }
42441   }
42442
42443 }
42444
42445
42446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42447   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42448   unsigned int arg2 ;
42449
42450   arg1 = (Dali::TapGestureDetector *)jarg1;
42451   arg2 = (unsigned int)jarg2;
42452   {
42453     try {
42454       (arg1)->SetMaximumTapsRequired(arg2);
42455     } catch (std::out_of_range& e) {
42456       {
42457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42458       };
42459     } catch (std::exception& e) {
42460       {
42461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42462       };
42463     } catch (Dali::DaliException e) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42466       };
42467     } catch (...) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42470       };
42471     }
42472   }
42473
42474 }
42475
42476
42477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42478   unsigned int jresult ;
42479   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42480   unsigned int result;
42481
42482   arg1 = (Dali::TapGestureDetector *)jarg1;
42483   {
42484     try {
42485       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42501       };
42502     }
42503   }
42504
42505   jresult = result;
42506   return jresult;
42507 }
42508
42509
42510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42511   unsigned int jresult ;
42512   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42513   unsigned int result;
42514
42515   arg1 = (Dali::TapGestureDetector *)jarg1;
42516   {
42517     try {
42518       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42534       };
42535     }
42536   }
42537
42538   jresult = result;
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42544   void * jresult ;
42545   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42546   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42547
42548   arg1 = (Dali::TapGestureDetector *)jarg1;
42549   {
42550     try {
42551       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42552     } catch (std::out_of_range& e) {
42553       {
42554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42555       };
42556     } catch (std::exception& e) {
42557       {
42558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (Dali::DaliException e) {
42561       {
42562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42563       };
42564     } catch (...) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42567       };
42568     }
42569   }
42570
42571   jresult = (void *)result;
42572   return jresult;
42573 }
42574
42575
42576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42577   void * jresult ;
42578   Dali::TapGesture *result = 0 ;
42579
42580   {
42581     try {
42582       result = (Dali::TapGesture *)new Dali::TapGesture();
42583     } catch (std::out_of_range& e) {
42584       {
42585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42586       };
42587     } catch (std::exception& e) {
42588       {
42589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (Dali::DaliException e) {
42592       {
42593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42594       };
42595     } catch (...) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42598       };
42599     }
42600   }
42601
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42608   void * jresult ;
42609   Dali::TapGesture *arg1 = 0 ;
42610   Dali::TapGesture *result = 0 ;
42611
42612   arg1 = (Dali::TapGesture *)jarg1;
42613   if (!arg1) {
42614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42615     return 0;
42616   }
42617   {
42618     try {
42619       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42620     } catch (std::out_of_range& e) {
42621       {
42622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (std::exception& e) {
42625       {
42626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (Dali::DaliException e) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42631       };
42632     } catch (...) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42635       };
42636     }
42637   }
42638
42639   jresult = (void *)result;
42640   return jresult;
42641 }
42642
42643
42644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42645   void * jresult ;
42646   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42647   Dali::TapGesture *arg2 = 0 ;
42648   Dali::TapGesture *result = 0 ;
42649
42650   arg1 = (Dali::TapGesture *)jarg1;
42651   arg2 = (Dali::TapGesture *)jarg2;
42652   if (!arg2) {
42653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42654     return 0;
42655   }
42656   {
42657     try {
42658       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42659     } catch (std::out_of_range& e) {
42660       {
42661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (std::exception& e) {
42664       {
42665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (Dali::DaliException e) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42670       };
42671     } catch (...) {
42672       {
42673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42674       };
42675     }
42676   }
42677
42678   jresult = (void *)result;
42679   return jresult;
42680 }
42681
42682
42683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42684   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42685
42686   arg1 = (Dali::TapGesture *)jarg1;
42687   {
42688     try {
42689       delete arg1;
42690     } catch (std::out_of_range& e) {
42691       {
42692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42693       };
42694     } catch (std::exception& e) {
42695       {
42696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42697       };
42698     } catch (Dali::DaliException e) {
42699       {
42700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42701       };
42702     } catch (...) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42705       };
42706     }
42707   }
42708
42709 }
42710
42711
42712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42713   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42714   unsigned int arg2 ;
42715
42716   arg1 = (Dali::TapGesture *)jarg1;
42717   arg2 = (unsigned int)jarg2;
42718   if (arg1) (arg1)->numberOfTaps = arg2;
42719 }
42720
42721
42722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42723   unsigned int jresult ;
42724   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42725   unsigned int result;
42726
42727   arg1 = (Dali::TapGesture *)jarg1;
42728   result = (unsigned int) ((arg1)->numberOfTaps);
42729   jresult = result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42735   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42736   unsigned int arg2 ;
42737
42738   arg1 = (Dali::TapGesture *)jarg1;
42739   arg2 = (unsigned int)jarg2;
42740   if (arg1) (arg1)->numberOfTouches = arg2;
42741 }
42742
42743
42744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42745   unsigned int jresult ;
42746   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42747   unsigned int result;
42748
42749   arg1 = (Dali::TapGesture *)jarg1;
42750   result = (unsigned int) ((arg1)->numberOfTouches);
42751   jresult = result;
42752   return jresult;
42753 }
42754
42755
42756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42757   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42758   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42759
42760   arg1 = (Dali::TapGesture *)jarg1;
42761   arg2 = (Dali::Vector2 *)jarg2;
42762   if (arg1) (arg1)->screenPoint = *arg2;
42763 }
42764
42765
42766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42767   void * jresult ;
42768   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42769   Dali::Vector2 *result = 0 ;
42770
42771   arg1 = (Dali::TapGesture *)jarg1;
42772   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42773   jresult = (void *)result;
42774   return jresult;
42775 }
42776
42777
42778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42779   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42780   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42781
42782   arg1 = (Dali::TapGesture *)jarg1;
42783   arg2 = (Dali::Vector2 *)jarg2;
42784   if (arg1) (arg1)->localPoint = *arg2;
42785 }
42786
42787
42788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42789   void * jresult ;
42790   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42791   Dali::Vector2 *result = 0 ;
42792
42793   arg1 = (Dali::TapGesture *)jarg1;
42794   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42795   jresult = (void *)result;
42796   return jresult;
42797 }
42798
42799
42800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42801   void * jresult ;
42802   Dali::AlphaFunction *result = 0 ;
42803
42804   {
42805     try {
42806       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42807     } catch (std::out_of_range& e) {
42808       {
42809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42810       };
42811     } catch (std::exception& e) {
42812       {
42813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (Dali::DaliException e) {
42816       {
42817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42818       };
42819     } catch (...) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42822       };
42823     }
42824   }
42825
42826   jresult = (void *)result;
42827   return jresult;
42828 }
42829
42830
42831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42832   void * jresult ;
42833   Dali::AlphaFunction::BuiltinFunction arg1 ;
42834   Dali::AlphaFunction *result = 0 ;
42835
42836   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42837   {
42838     try {
42839       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42840     } catch (std::out_of_range& e) {
42841       {
42842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42843       };
42844     } catch (std::exception& e) {
42845       {
42846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (Dali::DaliException e) {
42849       {
42850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42851       };
42852     } catch (...) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42855       };
42856     }
42857   }
42858
42859   jresult = (void *)result;
42860   return jresult;
42861 }
42862
42863
42864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42865   void * jresult ;
42866   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42867   Dali::AlphaFunction *result = 0 ;
42868
42869   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42870   {
42871     try {
42872       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42873     } catch (std::out_of_range& e) {
42874       {
42875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42876       };
42877     } catch (std::exception& e) {
42878       {
42879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (Dali::DaliException e) {
42882       {
42883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42884       };
42885     } catch (...) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42888       };
42889     }
42890   }
42891
42892   jresult = (void *)result;
42893   return jresult;
42894 }
42895
42896
42897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42898   void * jresult ;
42899   Dali::Vector2 *arg1 = 0 ;
42900   Dali::Vector2 *arg2 = 0 ;
42901   Dali::AlphaFunction *result = 0 ;
42902
42903   arg1 = (Dali::Vector2 *)jarg1;
42904   if (!arg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42906     return 0;
42907   }
42908   arg2 = (Dali::Vector2 *)jarg2;
42909   if (!arg2) {
42910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42911     return 0;
42912   }
42913   {
42914     try {
42915       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42916     } catch (std::out_of_range& e) {
42917       {
42918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42919       };
42920     } catch (std::exception& e) {
42921       {
42922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (Dali::DaliException e) {
42925       {
42926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934
42935   jresult = (void *)result;
42936   return jresult;
42937 }
42938
42939
42940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42941   void * jresult ;
42942   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42943   Dali::Vector4 result;
42944
42945   arg1 = (Dali::AlphaFunction *)jarg1;
42946   {
42947     try {
42948       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42949     } catch (std::out_of_range& e) {
42950       {
42951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42952       };
42953     } catch (std::exception& e) {
42954       {
42955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42956       };
42957     } catch (Dali::DaliException e) {
42958       {
42959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42960       };
42961     } catch (...) {
42962       {
42963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42964       };
42965     }
42966   }
42967
42968   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42969   return jresult;
42970 }
42971
42972
42973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42974   void * jresult ;
42975   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42976   Dali::AlphaFunctionPrototype result;
42977
42978   arg1 = (Dali::AlphaFunction *)jarg1;
42979   {
42980     try {
42981       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42982     } catch (std::out_of_range& e) {
42983       {
42984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (std::exception& e) {
42987       {
42988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (Dali::DaliException e) {
42991       {
42992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42993       };
42994     } catch (...) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42997       };
42998     }
42999   }
43000
43001   jresult = (void *)result;
43002   return jresult;
43003 }
43004
43005
43006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43007   int jresult ;
43008   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43009   Dali::AlphaFunction::BuiltinFunction result;
43010
43011   arg1 = (Dali::AlphaFunction *)jarg1;
43012   {
43013     try {
43014       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43015     } catch (std::out_of_range& e) {
43016       {
43017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43018       };
43019     } catch (std::exception& e) {
43020       {
43021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43022       };
43023     } catch (Dali::DaliException e) {
43024       {
43025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43026       };
43027     } catch (...) {
43028       {
43029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43030       };
43031     }
43032   }
43033
43034   jresult = (int)result;
43035   return jresult;
43036 }
43037
43038
43039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43040   int jresult ;
43041   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43042   Dali::AlphaFunction::Mode result;
43043
43044   arg1 = (Dali::AlphaFunction *)jarg1;
43045   {
43046     try {
43047       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43048     } catch (std::out_of_range& e) {
43049       {
43050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43051       };
43052     } catch (std::exception& e) {
43053       {
43054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (Dali::DaliException e) {
43057       {
43058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43059       };
43060     } catch (...) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43063       };
43064     }
43065   }
43066
43067   jresult = (int)result;
43068   return jresult;
43069 }
43070
43071
43072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43073   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43074
43075   arg1 = (Dali::AlphaFunction *)jarg1;
43076   {
43077     try {
43078       delete arg1;
43079     } catch (std::out_of_range& e) {
43080       {
43081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43082       };
43083     } catch (std::exception& e) {
43084       {
43085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (Dali::DaliException e) {
43088       {
43089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43094       };
43095     }
43096   }
43097
43098 }
43099
43100
43101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43102   void * jresult ;
43103   Dali::KeyFrames result;
43104
43105   {
43106     try {
43107       result = Dali::KeyFrames::New();
43108     } catch (std::out_of_range& e) {
43109       {
43110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43111       };
43112     } catch (std::exception& e) {
43113       {
43114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (Dali::DaliException e) {
43117       {
43118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43119       };
43120     } catch (...) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43123       };
43124     }
43125   }
43126
43127   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43128   return jresult;
43129 }
43130
43131
43132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43133   void * jresult ;
43134   Dali::BaseHandle arg1 ;
43135   Dali::BaseHandle *argp1 ;
43136   Dali::KeyFrames result;
43137
43138   argp1 = (Dali::BaseHandle *)jarg1;
43139   if (!argp1) {
43140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43141     return 0;
43142   }
43143   arg1 = *argp1;
43144   {
43145     try {
43146       result = Dali::KeyFrames::DownCast(arg1);
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (Dali::DaliException e) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43158       };
43159     } catch (...) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43162       };
43163     }
43164   }
43165
43166   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43167   return jresult;
43168 }
43169
43170
43171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43172   void * jresult ;
43173   Dali::KeyFrames *result = 0 ;
43174
43175   {
43176     try {
43177       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43178     } catch (std::out_of_range& e) {
43179       {
43180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43181       };
43182     } catch (std::exception& e) {
43183       {
43184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (Dali::DaliException e) {
43187       {
43188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43189       };
43190     } catch (...) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43193       };
43194     }
43195   }
43196
43197   jresult = (void *)result;
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43203   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43204
43205   arg1 = (Dali::KeyFrames *)jarg1;
43206   {
43207     try {
43208       delete arg1;
43209     } catch (std::out_of_range& e) {
43210       {
43211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43212       };
43213     } catch (std::exception& e) {
43214       {
43215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43216       };
43217     } catch (Dali::DaliException e) {
43218       {
43219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43220       };
43221     } catch (...) {
43222       {
43223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43224       };
43225     }
43226   }
43227
43228 }
43229
43230
43231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43232   void * jresult ;
43233   Dali::KeyFrames *arg1 = 0 ;
43234   Dali::KeyFrames *result = 0 ;
43235
43236   arg1 = (Dali::KeyFrames *)jarg1;
43237   if (!arg1) {
43238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43239     return 0;
43240   }
43241   {
43242     try {
43243       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43244     } catch (std::out_of_range& e) {
43245       {
43246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43247       };
43248     } catch (std::exception& e) {
43249       {
43250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43251       };
43252     } catch (Dali::DaliException e) {
43253       {
43254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43255       };
43256     } catch (...) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43259       };
43260     }
43261   }
43262
43263   jresult = (void *)result;
43264   return jresult;
43265 }
43266
43267
43268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43269   void * jresult ;
43270   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43271   Dali::KeyFrames *arg2 = 0 ;
43272   Dali::KeyFrames *result = 0 ;
43273
43274   arg1 = (Dali::KeyFrames *)jarg1;
43275   arg2 = (Dali::KeyFrames *)jarg2;
43276   if (!arg2) {
43277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43278     return 0;
43279   }
43280   {
43281     try {
43282       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43283     } catch (std::out_of_range& e) {
43284       {
43285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43286       };
43287     } catch (std::exception& e) {
43288       {
43289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43290       };
43291     } catch (Dali::DaliException e) {
43292       {
43293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43294       };
43295     } catch (...) {
43296       {
43297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43298       };
43299     }
43300   }
43301
43302   jresult = (void *)result;
43303   return jresult;
43304 }
43305
43306
43307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43308   int jresult ;
43309   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43310   Dali::Property::Type result;
43311
43312   arg1 = (Dali::KeyFrames *)jarg1;
43313   {
43314     try {
43315       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43316     } catch (std::out_of_range& e) {
43317       {
43318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43319       };
43320     } catch (std::exception& e) {
43321       {
43322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (Dali::DaliException e) {
43325       {
43326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43327       };
43328     } catch (...) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43331       };
43332     }
43333   }
43334
43335   jresult = (int)result;
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43341   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43342   float arg2 ;
43343   Dali::Property::Value arg3 ;
43344   Dali::Property::Value *argp3 ;
43345
43346   arg1 = (Dali::KeyFrames *)jarg1;
43347   arg2 = (float)jarg2;
43348   argp3 = (Dali::Property::Value *)jarg3;
43349   if (!argp3) {
43350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43351     return ;
43352   }
43353   arg3 = *argp3;
43354   {
43355     try {
43356       (arg1)->Add(arg2,arg3);
43357     } catch (std::out_of_range& e) {
43358       {
43359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43360       };
43361     } catch (std::exception& e) {
43362       {
43363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (Dali::DaliException e) {
43366       {
43367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43368       };
43369     } catch (...) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43372       };
43373     }
43374   }
43375
43376 }
43377
43378
43379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43380   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43381   float arg2 ;
43382   Dali::Property::Value arg3 ;
43383   Dali::AlphaFunction arg4 ;
43384   Dali::Property::Value *argp3 ;
43385   Dali::AlphaFunction *argp4 ;
43386
43387   arg1 = (Dali::KeyFrames *)jarg1;
43388   arg2 = (float)jarg2;
43389   argp3 = (Dali::Property::Value *)jarg3;
43390   if (!argp3) {
43391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43392     return ;
43393   }
43394   arg3 = *argp3;
43395   argp4 = (Dali::AlphaFunction *)jarg4;
43396   if (!argp4) {
43397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43398     return ;
43399   }
43400   arg4 = *argp4;
43401   {
43402     try {
43403       (arg1)->Add(arg2,arg3,arg4);
43404     } catch (std::out_of_range& e) {
43405       {
43406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43407       };
43408     } catch (std::exception& e) {
43409       {
43410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (Dali::DaliException e) {
43413       {
43414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43419       };
43420     }
43421   }
43422
43423 }
43424
43425
43426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43427   int jresult ;
43428   int result;
43429
43430   result = (int)Dali::Path::Property::POINTS;
43431   jresult = (int)result;
43432   return jresult;
43433 }
43434
43435
43436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43437   int jresult ;
43438   int result;
43439
43440   result = (int)Dali::Path::Property::CONTROL_POINTS;
43441   jresult = (int)result;
43442   return jresult;
43443 }
43444
43445
43446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43447   void * jresult ;
43448   Dali::Path::Property *result = 0 ;
43449
43450   {
43451     try {
43452       result = (Dali::Path::Property *)new Dali::Path::Property();
43453     } catch (std::out_of_range& e) {
43454       {
43455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43456       };
43457     } catch (std::exception& e) {
43458       {
43459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (Dali::DaliException e) {
43462       {
43463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43464       };
43465     } catch (...) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43468       };
43469     }
43470   }
43471
43472   jresult = (void *)result;
43473   return jresult;
43474 }
43475
43476
43477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43478   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43479
43480   arg1 = (Dali::Path::Property *)jarg1;
43481   {
43482     try {
43483       delete arg1;
43484     } catch (std::out_of_range& e) {
43485       {
43486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43487       };
43488     } catch (std::exception& e) {
43489       {
43490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43491       };
43492     } catch (Dali::DaliException e) {
43493       {
43494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43495       };
43496     } catch (...) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43499       };
43500     }
43501   }
43502
43503 }
43504
43505
43506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43507   void * jresult ;
43508   Dali::Path result;
43509
43510   {
43511     try {
43512       result = Dali::Path::New();
43513     } catch (std::out_of_range& e) {
43514       {
43515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43516       };
43517     } catch (std::exception& e) {
43518       {
43519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (Dali::DaliException e) {
43522       {
43523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43524       };
43525     } catch (...) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43528       };
43529     }
43530   }
43531
43532   jresult = new Dali::Path((const Dali::Path &)result);
43533   return jresult;
43534 }
43535
43536
43537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43538   void * jresult ;
43539   Dali::BaseHandle arg1 ;
43540   Dali::BaseHandle *argp1 ;
43541   Dali::Path result;
43542
43543   argp1 = (Dali::BaseHandle *)jarg1;
43544   if (!argp1) {
43545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43546     return 0;
43547   }
43548   arg1 = *argp1;
43549   {
43550     try {
43551       result = Dali::Path::DownCast(arg1);
43552     } catch (std::out_of_range& e) {
43553       {
43554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43555       };
43556     } catch (std::exception& e) {
43557       {
43558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43559       };
43560     } catch (Dali::DaliException e) {
43561       {
43562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43563       };
43564     } catch (...) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43567       };
43568     }
43569   }
43570
43571   jresult = new Dali::Path((const Dali::Path &)result);
43572   return jresult;
43573 }
43574
43575
43576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43577   void * jresult ;
43578   Dali::Path *result = 0 ;
43579
43580   {
43581     try {
43582       result = (Dali::Path *)new Dali::Path();
43583     } catch (std::out_of_range& e) {
43584       {
43585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43586       };
43587     } catch (std::exception& e) {
43588       {
43589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43590       };
43591     } catch (Dali::DaliException e) {
43592       {
43593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43594       };
43595     } catch (...) {
43596       {
43597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43598       };
43599     }
43600   }
43601
43602   jresult = (void *)result;
43603   return jresult;
43604 }
43605
43606
43607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43608   Dali::Path *arg1 = (Dali::Path *) 0 ;
43609
43610   arg1 = (Dali::Path *)jarg1;
43611   {
43612     try {
43613       delete arg1;
43614     } catch (std::out_of_range& e) {
43615       {
43616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43617       };
43618     } catch (std::exception& e) {
43619       {
43620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43621       };
43622     } catch (Dali::DaliException e) {
43623       {
43624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43625       };
43626     } catch (...) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43629       };
43630     }
43631   }
43632
43633 }
43634
43635
43636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43637   void * jresult ;
43638   Dali::Path *arg1 = 0 ;
43639   Dali::Path *result = 0 ;
43640
43641   arg1 = (Dali::Path *)jarg1;
43642   if (!arg1) {
43643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43644     return 0;
43645   }
43646   {
43647     try {
43648       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43649     } catch (std::out_of_range& e) {
43650       {
43651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43652       };
43653     } catch (std::exception& e) {
43654       {
43655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (Dali::DaliException e) {
43658       {
43659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43660       };
43661     } catch (...) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43664       };
43665     }
43666   }
43667
43668   jresult = (void *)result;
43669   return jresult;
43670 }
43671
43672
43673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43674   void * jresult ;
43675   Dali::Path *arg1 = (Dali::Path *) 0 ;
43676   Dali::Path *arg2 = 0 ;
43677   Dali::Path *result = 0 ;
43678
43679   arg1 = (Dali::Path *)jarg1;
43680   arg2 = (Dali::Path *)jarg2;
43681   if (!arg2) {
43682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43683     return 0;
43684   }
43685   {
43686     try {
43687       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43688     } catch (std::out_of_range& e) {
43689       {
43690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43691       };
43692     } catch (std::exception& e) {
43693       {
43694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43695       };
43696     } catch (Dali::DaliException e) {
43697       {
43698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43699       };
43700     } catch (...) {
43701       {
43702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43703       };
43704     }
43705   }
43706
43707   jresult = (void *)result;
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43713   Dali::Path *arg1 = (Dali::Path *) 0 ;
43714   Dali::Vector3 *arg2 = 0 ;
43715
43716   arg1 = (Dali::Path *)jarg1;
43717   arg2 = (Dali::Vector3 *)jarg2;
43718   if (!arg2) {
43719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43720     return ;
43721   }
43722   {
43723     try {
43724       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43725     } catch (std::out_of_range& e) {
43726       {
43727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43728       };
43729     } catch (std::exception& e) {
43730       {
43731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43732       };
43733     } catch (Dali::DaliException e) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43736       };
43737     } catch (...) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43740       };
43741     }
43742   }
43743
43744 }
43745
43746
43747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43748   Dali::Path *arg1 = (Dali::Path *) 0 ;
43749   Dali::Vector3 *arg2 = 0 ;
43750
43751   arg1 = (Dali::Path *)jarg1;
43752   arg2 = (Dali::Vector3 *)jarg2;
43753   if (!arg2) {
43754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43755     return ;
43756   }
43757   {
43758     try {
43759       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43760     } catch (std::out_of_range& e) {
43761       {
43762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43763       };
43764     } catch (std::exception& e) {
43765       {
43766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43767       };
43768     } catch (Dali::DaliException e) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43771       };
43772     } catch (...) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43775       };
43776     }
43777   }
43778
43779 }
43780
43781
43782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43783   Dali::Path *arg1 = (Dali::Path *) 0 ;
43784   float arg2 ;
43785
43786   arg1 = (Dali::Path *)jarg1;
43787   arg2 = (float)jarg2;
43788   {
43789     try {
43790       (arg1)->GenerateControlPoints(arg2);
43791     } catch (std::out_of_range& e) {
43792       {
43793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43794       };
43795     } catch (std::exception& e) {
43796       {
43797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43798       };
43799     } catch (Dali::DaliException e) {
43800       {
43801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43802       };
43803     } catch (...) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43806       };
43807     }
43808   }
43809
43810 }
43811
43812
43813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43814   Dali::Path *arg1 = (Dali::Path *) 0 ;
43815   float arg2 ;
43816   Dali::Vector3 *arg3 = 0 ;
43817   Dali::Vector3 *arg4 = 0 ;
43818
43819   arg1 = (Dali::Path *)jarg1;
43820   arg2 = (float)jarg2;
43821   arg3 = (Dali::Vector3 *)jarg3;
43822   if (!arg3) {
43823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43824     return ;
43825   }
43826   arg4 = (Dali::Vector3 *)jarg4;
43827   if (!arg4) {
43828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43829     return ;
43830   }
43831   {
43832     try {
43833       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43834     } catch (std::out_of_range& e) {
43835       {
43836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43837       };
43838     } catch (std::exception& e) {
43839       {
43840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43841       };
43842     } catch (Dali::DaliException e) {
43843       {
43844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43845       };
43846     } catch (...) {
43847       {
43848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43849       };
43850     }
43851   }
43852
43853 }
43854
43855
43856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43857   void * jresult ;
43858   Dali::Path *arg1 = (Dali::Path *) 0 ;
43859   size_t arg2 ;
43860   Dali::Vector3 *result = 0 ;
43861
43862   arg1 = (Dali::Path *)jarg1;
43863   arg2 = (size_t)jarg2;
43864   {
43865     try {
43866       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43867     } catch (std::out_of_range& e) {
43868       {
43869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43870       };
43871     } catch (std::exception& e) {
43872       {
43873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43874       };
43875     } catch (Dali::DaliException e) {
43876       {
43877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43878       };
43879     } catch (...) {
43880       {
43881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43882       };
43883     }
43884   }
43885
43886   jresult = (void *)result;
43887   return jresult;
43888 }
43889
43890
43891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43892   void * jresult ;
43893   Dali::Path *arg1 = (Dali::Path *) 0 ;
43894   size_t arg2 ;
43895   Dali::Vector3 *result = 0 ;
43896
43897   arg1 = (Dali::Path *)jarg1;
43898   arg2 = (size_t)jarg2;
43899   {
43900     try {
43901       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43902     } catch (std::out_of_range& e) {
43903       {
43904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43905       };
43906     } catch (std::exception& e) {
43907       {
43908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43909       };
43910     } catch (Dali::DaliException e) {
43911       {
43912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43913       };
43914     } catch (...) {
43915       {
43916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43917       };
43918     }
43919   }
43920
43921   jresult = (void *)result;
43922   return jresult;
43923 }
43924
43925
43926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43927   unsigned long jresult ;
43928   Dali::Path *arg1 = (Dali::Path *) 0 ;
43929   size_t result;
43930
43931   arg1 = (Dali::Path *)jarg1;
43932   {
43933     try {
43934       result = ((Dali::Path const *)arg1)->GetPointCount();
43935     } catch (std::out_of_range& e) {
43936       {
43937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43938       };
43939     } catch (std::exception& e) {
43940       {
43941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (Dali::DaliException e) {
43944       {
43945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43946       };
43947     } catch (...) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43950       };
43951     }
43952   }
43953
43954   jresult = (unsigned long)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43960   void * jresult ;
43961   float arg1 ;
43962   Dali::TimePeriod *result = 0 ;
43963
43964   arg1 = (float)jarg1;
43965   {
43966     try {
43967       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43968     } catch (std::out_of_range& e) {
43969       {
43970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43971       };
43972     } catch (std::exception& e) {
43973       {
43974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43975       };
43976     } catch (Dali::DaliException e) {
43977       {
43978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43979       };
43980     } catch (...) {
43981       {
43982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43983       };
43984     }
43985   }
43986
43987   jresult = (void *)result;
43988   return jresult;
43989 }
43990
43991
43992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43993   void * jresult ;
43994   float arg1 ;
43995   float arg2 ;
43996   Dali::TimePeriod *result = 0 ;
43997
43998   arg1 = (float)jarg1;
43999   arg2 = (float)jarg2;
44000   {
44001     try {
44002       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44018       };
44019     }
44020   }
44021
44022   jresult = (void *)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44028   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44029
44030   arg1 = (Dali::TimePeriod *)jarg1;
44031   {
44032     try {
44033       delete arg1;
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44049       };
44050     }
44051   }
44052
44053 }
44054
44055
44056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44057   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44058   float arg2 ;
44059
44060   arg1 = (Dali::TimePeriod *)jarg1;
44061   arg2 = (float)jarg2;
44062   if (arg1) (arg1)->delaySeconds = arg2;
44063 }
44064
44065
44066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44067   float jresult ;
44068   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44069   float result;
44070
44071   arg1 = (Dali::TimePeriod *)jarg1;
44072   result = (float) ((arg1)->delaySeconds);
44073   jresult = result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44079   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44080   float arg2 ;
44081
44082   arg1 = (Dali::TimePeriod *)jarg1;
44083   arg2 = (float)jarg2;
44084   if (arg1) (arg1)->durationSeconds = arg2;
44085 }
44086
44087
44088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44089   float jresult ;
44090   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44091   float result;
44092
44093   arg1 = (Dali::TimePeriod *)jarg1;
44094   result = (float) ((arg1)->durationSeconds);
44095   jresult = result;
44096   return jresult;
44097 }
44098
44099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44100   int jresult ;
44101   int result;
44102
44103   result = (int)Dali::LinearConstrainer::Property::VALUE;
44104   jresult = (int)result;
44105   return jresult;
44106 }
44107
44108
44109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44110   int jresult ;
44111   int result;
44112
44113   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44114   jresult = (int)result;
44115   return jresult;
44116 }
44117
44118
44119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44120   void * jresult ;
44121   Dali::LinearConstrainer::Property *result = 0 ;
44122
44123   {
44124     try {
44125       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44126     } catch (std::out_of_range& e) {
44127       {
44128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44129       };
44130     } catch (std::exception& e) {
44131       {
44132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44133       };
44134     } catch (Dali::DaliException e) {
44135       {
44136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44137       };
44138     } catch (...) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44141       };
44142     }
44143   }
44144
44145   jresult = (void *)result;
44146   return jresult;
44147 }
44148
44149
44150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44151   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44152
44153   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44154   {
44155     try {
44156       delete arg1;
44157     } catch (std::out_of_range& e) {
44158       {
44159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44160       };
44161     } catch (std::exception& e) {
44162       {
44163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44164       };
44165     } catch (Dali::DaliException e) {
44166       {
44167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44168       };
44169     } catch (...) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44172       };
44173     }
44174   }
44175
44176 }
44177
44178
44179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44180   void * jresult ;
44181   Dali::LinearConstrainer result;
44182
44183   {
44184     try {
44185       result = Dali::LinearConstrainer::New();
44186     } catch (std::out_of_range& e) {
44187       {
44188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44189       };
44190     } catch (std::exception& e) {
44191       {
44192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (Dali::DaliException e) {
44195       {
44196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44197       };
44198     } catch (...) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44201       };
44202     }
44203   }
44204
44205   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44206   return jresult;
44207 }
44208
44209
44210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44211   void * jresult ;
44212   Dali::BaseHandle arg1 ;
44213   Dali::BaseHandle *argp1 ;
44214   Dali::LinearConstrainer result;
44215
44216   argp1 = (Dali::BaseHandle *)jarg1;
44217   if (!argp1) {
44218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44219     return 0;
44220   }
44221   arg1 = *argp1;
44222   {
44223     try {
44224       result = Dali::LinearConstrainer::DownCast(arg1);
44225     } catch (std::out_of_range& e) {
44226       {
44227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44228       };
44229     } catch (std::exception& e) {
44230       {
44231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (Dali::DaliException e) {
44234       {
44235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44240       };
44241     }
44242   }
44243
44244   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44245   return jresult;
44246 }
44247
44248
44249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44250   void * jresult ;
44251   Dali::LinearConstrainer *result = 0 ;
44252
44253   {
44254     try {
44255       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44256     } catch (std::out_of_range& e) {
44257       {
44258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44259       };
44260     } catch (std::exception& e) {
44261       {
44262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44263       };
44264     } catch (Dali::DaliException e) {
44265       {
44266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44267       };
44268     } catch (...) {
44269       {
44270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44271       };
44272     }
44273   }
44274
44275   jresult = (void *)result;
44276   return jresult;
44277 }
44278
44279
44280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44281   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44282
44283   arg1 = (Dali::LinearConstrainer *)jarg1;
44284   {
44285     try {
44286       delete arg1;
44287     } catch (std::out_of_range& e) {
44288       {
44289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (std::exception& e) {
44292       {
44293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (Dali::DaliException e) {
44296       {
44297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44298       };
44299     } catch (...) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44302       };
44303     }
44304   }
44305
44306 }
44307
44308
44309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44310   void * jresult ;
44311   Dali::LinearConstrainer *arg1 = 0 ;
44312   Dali::LinearConstrainer *result = 0 ;
44313
44314   arg1 = (Dali::LinearConstrainer *)jarg1;
44315   if (!arg1) {
44316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44317     return 0;
44318   }
44319   {
44320     try {
44321       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44322     } catch (std::out_of_range& e) {
44323       {
44324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44325       };
44326     } catch (std::exception& e) {
44327       {
44328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (Dali::DaliException e) {
44331       {
44332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44333       };
44334     } catch (...) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44337       };
44338     }
44339   }
44340
44341   jresult = (void *)result;
44342   return jresult;
44343 }
44344
44345
44346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44347   void * jresult ;
44348   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44349   Dali::LinearConstrainer *arg2 = 0 ;
44350   Dali::LinearConstrainer *result = 0 ;
44351
44352   arg1 = (Dali::LinearConstrainer *)jarg1;
44353   arg2 = (Dali::LinearConstrainer *)jarg2;
44354   if (!arg2) {
44355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44356     return 0;
44357   }
44358   {
44359     try {
44360       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44361     } catch (std::out_of_range& e) {
44362       {
44363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44364       };
44365     } catch (std::exception& e) {
44366       {
44367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (Dali::DaliException e) {
44370       {
44371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44372       };
44373     } catch (...) {
44374       {
44375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44376       };
44377     }
44378   }
44379
44380   jresult = (void *)result;
44381   return jresult;
44382 }
44383
44384
44385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44386   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44387   SwigValueWrapper< Dali::Property > arg2 ;
44388   SwigValueWrapper< Dali::Property > arg3 ;
44389   Dali::Vector2 *arg4 = 0 ;
44390   Dali::Vector2 *arg5 = 0 ;
44391   Dali::Property *argp2 ;
44392   Dali::Property *argp3 ;
44393
44394   arg1 = (Dali::LinearConstrainer *)jarg1;
44395   argp2 = (Dali::Property *)jarg2;
44396   if (!argp2) {
44397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44398     return ;
44399   }
44400   arg2 = *argp2;
44401   argp3 = (Dali::Property *)jarg3;
44402   if (!argp3) {
44403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44404     return ;
44405   }
44406   arg3 = *argp3;
44407   arg4 = (Dali::Vector2 *)jarg4;
44408   if (!arg4) {
44409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44410     return ;
44411   }
44412   arg5 = (Dali::Vector2 *)jarg5;
44413   if (!arg5) {
44414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44415     return ;
44416   }
44417   {
44418     try {
44419       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44420     } catch (std::out_of_range& e) {
44421       {
44422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44423       };
44424     } catch (std::exception& e) {
44425       {
44426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44427       };
44428     } catch (Dali::DaliException e) {
44429       {
44430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44431       };
44432     } catch (...) {
44433       {
44434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44435       };
44436     }
44437   }
44438
44439 }
44440
44441
44442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44443   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44444   SwigValueWrapper< Dali::Property > arg2 ;
44445   SwigValueWrapper< Dali::Property > arg3 ;
44446   Dali::Vector2 *arg4 = 0 ;
44447   Dali::Property *argp2 ;
44448   Dali::Property *argp3 ;
44449
44450   arg1 = (Dali::LinearConstrainer *)jarg1;
44451   argp2 = (Dali::Property *)jarg2;
44452   if (!argp2) {
44453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44454     return ;
44455   }
44456   arg2 = *argp2;
44457   argp3 = (Dali::Property *)jarg3;
44458   if (!argp3) {
44459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44460     return ;
44461   }
44462   arg3 = *argp3;
44463   arg4 = (Dali::Vector2 *)jarg4;
44464   if (!arg4) {
44465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44466     return ;
44467   }
44468   {
44469     try {
44470       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (Dali::DaliException e) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44482       };
44483     } catch (...) {
44484       {
44485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44486       };
44487     }
44488   }
44489
44490 }
44491
44492
44493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44494   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44495   Dali::Handle *arg2 = 0 ;
44496
44497   arg1 = (Dali::LinearConstrainer *)jarg1;
44498   arg2 = (Dali::Handle *)jarg2;
44499   if (!arg2) {
44500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44501     return ;
44502   }
44503   {
44504     try {
44505       (arg1)->Remove(*arg2);
44506     } catch (std::out_of_range& e) {
44507       {
44508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44509       };
44510     } catch (std::exception& e) {
44511       {
44512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (Dali::DaliException e) {
44515       {
44516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44517       };
44518     } catch (...) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44521       };
44522     }
44523   }
44524
44525 }
44526
44527
44528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44529   int jresult ;
44530   int result;
44531
44532   result = (int)Dali::PathConstrainer::Property::FORWARD;
44533   jresult = (int)result;
44534   return jresult;
44535 }
44536
44537
44538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44539   int jresult ;
44540   int result;
44541
44542   result = (int)Dali::PathConstrainer::Property::POINTS;
44543   jresult = (int)result;
44544   return jresult;
44545 }
44546
44547
44548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44549   int jresult ;
44550   int result;
44551
44552   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44553   jresult = (int)result;
44554   return jresult;
44555 }
44556
44557
44558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44559   void * jresult ;
44560   Dali::PathConstrainer::Property *result = 0 ;
44561
44562   {
44563     try {
44564       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44565     } catch (std::out_of_range& e) {
44566       {
44567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44568       };
44569     } catch (std::exception& e) {
44570       {
44571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (Dali::DaliException e) {
44574       {
44575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44576       };
44577     } catch (...) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44580       };
44581     }
44582   }
44583
44584   jresult = (void *)result;
44585   return jresult;
44586 }
44587
44588
44589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44590   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44591
44592   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44593   {
44594     try {
44595       delete arg1;
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (Dali::DaliException e) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44607       };
44608     } catch (...) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44611       };
44612     }
44613   }
44614
44615 }
44616
44617
44618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44619   void * jresult ;
44620   Dali::PathConstrainer result;
44621
44622   {
44623     try {
44624       result = Dali::PathConstrainer::New();
44625     } catch (std::out_of_range& e) {
44626       {
44627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44628       };
44629     } catch (std::exception& e) {
44630       {
44631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (Dali::DaliException e) {
44634       {
44635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44636       };
44637     } catch (...) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44640       };
44641     }
44642   }
44643
44644   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44645   return jresult;
44646 }
44647
44648
44649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44650   void * jresult ;
44651   Dali::BaseHandle arg1 ;
44652   Dali::BaseHandle *argp1 ;
44653   Dali::PathConstrainer result;
44654
44655   argp1 = (Dali::BaseHandle *)jarg1;
44656   if (!argp1) {
44657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44658     return 0;
44659   }
44660   arg1 = *argp1;
44661   {
44662     try {
44663       result = Dali::PathConstrainer::DownCast(arg1);
44664     } catch (std::out_of_range& e) {
44665       {
44666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44667       };
44668     } catch (std::exception& e) {
44669       {
44670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44671       };
44672     } catch (Dali::DaliException e) {
44673       {
44674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44675       };
44676     } catch (...) {
44677       {
44678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44679       };
44680     }
44681   }
44682
44683   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44684   return jresult;
44685 }
44686
44687
44688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44689   void * jresult ;
44690   Dali::PathConstrainer *result = 0 ;
44691
44692   {
44693     try {
44694       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44695     } catch (std::out_of_range& e) {
44696       {
44697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44698       };
44699     } catch (std::exception& e) {
44700       {
44701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (Dali::DaliException e) {
44704       {
44705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44710       };
44711     }
44712   }
44713
44714   jresult = (void *)result;
44715   return jresult;
44716 }
44717
44718
44719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44720   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44721
44722   arg1 = (Dali::PathConstrainer *)jarg1;
44723   {
44724     try {
44725       delete arg1;
44726     } catch (std::out_of_range& e) {
44727       {
44728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44729       };
44730     } catch (std::exception& e) {
44731       {
44732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44733       };
44734     } catch (Dali::DaliException e) {
44735       {
44736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44737       };
44738     } catch (...) {
44739       {
44740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44741       };
44742     }
44743   }
44744
44745 }
44746
44747
44748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44749   void * jresult ;
44750   Dali::PathConstrainer *arg1 = 0 ;
44751   Dali::PathConstrainer *result = 0 ;
44752
44753   arg1 = (Dali::PathConstrainer *)jarg1;
44754   if (!arg1) {
44755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44756     return 0;
44757   }
44758   {
44759     try {
44760       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44761     } catch (std::out_of_range& e) {
44762       {
44763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44764       };
44765     } catch (std::exception& e) {
44766       {
44767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44768       };
44769     } catch (Dali::DaliException e) {
44770       {
44771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44772       };
44773     } catch (...) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44776       };
44777     }
44778   }
44779
44780   jresult = (void *)result;
44781   return jresult;
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44786   void * jresult ;
44787   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44788   Dali::PathConstrainer *arg2 = 0 ;
44789   Dali::PathConstrainer *result = 0 ;
44790
44791   arg1 = (Dali::PathConstrainer *)jarg1;
44792   arg2 = (Dali::PathConstrainer *)jarg2;
44793   if (!arg2) {
44794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44795     return 0;
44796   }
44797   {
44798     try {
44799       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44800     } catch (std::out_of_range& e) {
44801       {
44802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44803       };
44804     } catch (std::exception& e) {
44805       {
44806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44807       };
44808     } catch (Dali::DaliException e) {
44809       {
44810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44811       };
44812     } catch (...) {
44813       {
44814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44815       };
44816     }
44817   }
44818
44819   jresult = (void *)result;
44820   return jresult;
44821 }
44822
44823
44824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44825   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44826   SwigValueWrapper< Dali::Property > arg2 ;
44827   SwigValueWrapper< Dali::Property > arg3 ;
44828   Dali::Vector2 *arg4 = 0 ;
44829   Dali::Vector2 *arg5 = 0 ;
44830   Dali::Property *argp2 ;
44831   Dali::Property *argp3 ;
44832
44833   arg1 = (Dali::PathConstrainer *)jarg1;
44834   argp2 = (Dali::Property *)jarg2;
44835   if (!argp2) {
44836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44837     return ;
44838   }
44839   arg2 = *argp2;
44840   argp3 = (Dali::Property *)jarg3;
44841   if (!argp3) {
44842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44843     return ;
44844   }
44845   arg3 = *argp3;
44846   arg4 = (Dali::Vector2 *)jarg4;
44847   if (!arg4) {
44848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44849     return ;
44850   }
44851   arg5 = (Dali::Vector2 *)jarg5;
44852   if (!arg5) {
44853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44854     return ;
44855   }
44856   {
44857     try {
44858       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44859     } catch (std::out_of_range& e) {
44860       {
44861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44862       };
44863     } catch (std::exception& e) {
44864       {
44865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44866       };
44867     } catch (Dali::DaliException e) {
44868       {
44869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44870       };
44871     } catch (...) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44874       };
44875     }
44876   }
44877
44878 }
44879
44880
44881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44882   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44883   SwigValueWrapper< Dali::Property > arg2 ;
44884   SwigValueWrapper< Dali::Property > arg3 ;
44885   Dali::Vector2 *arg4 = 0 ;
44886   Dali::Property *argp2 ;
44887   Dali::Property *argp3 ;
44888
44889   arg1 = (Dali::PathConstrainer *)jarg1;
44890   argp2 = (Dali::Property *)jarg2;
44891   if (!argp2) {
44892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44893     return ;
44894   }
44895   arg2 = *argp2;
44896   argp3 = (Dali::Property *)jarg3;
44897   if (!argp3) {
44898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44899     return ;
44900   }
44901   arg3 = *argp3;
44902   arg4 = (Dali::Vector2 *)jarg4;
44903   if (!arg4) {
44904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44905     return ;
44906   }
44907   {
44908     try {
44909       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44910     } catch (std::out_of_range& e) {
44911       {
44912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44913       };
44914     } catch (std::exception& e) {
44915       {
44916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (Dali::DaliException e) {
44919       {
44920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44921       };
44922     } catch (...) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44925       };
44926     }
44927   }
44928
44929 }
44930
44931
44932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44933   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44934   Dali::Handle *arg2 = 0 ;
44935
44936   arg1 = (Dali::PathConstrainer *)jarg1;
44937   arg2 = (Dali::Handle *)jarg2;
44938   if (!arg2) {
44939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44940     return ;
44941   }
44942   {
44943     try {
44944       (arg1)->Remove(*arg2);
44945     } catch (std::out_of_range& e) {
44946       {
44947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44948       };
44949     } catch (std::exception& e) {
44950       {
44951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (Dali::DaliException e) {
44954       {
44955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44956       };
44957     } catch (...) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44960       };
44961     }
44962   }
44963
44964 }
44965
44966
44967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44968   int jresult ;
44969   Dali::FittingMode::Type result;
44970
44971   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44972   jresult = (int)result;
44973   return jresult;
44974 }
44975
44976
44977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44978   int jresult ;
44979   Dali::SamplingMode::Type result;
44980
44981   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44982   jresult = (int)result;
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44988   void * jresult ;
44989   Dali::BufferImage *result = 0 ;
44990
44991   {
44992     try {
44993       result = (Dali::BufferImage *)new Dali::BufferImage();
44994     } catch (std::out_of_range& e) {
44995       {
44996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44997       };
44998     } catch (std::exception& e) {
44999       {
45000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45001       };
45002     } catch (Dali::DaliException e) {
45003       {
45004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45005       };
45006     } catch (...) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45009       };
45010     }
45011   }
45012
45013   jresult = (void *)result;
45014   return jresult;
45015 }
45016
45017
45018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45019   void * jresult ;
45020   unsigned int arg1 ;
45021   unsigned int arg2 ;
45022   Dali::Pixel::Format arg3 ;
45023   Dali::BufferImage result;
45024
45025   arg1 = (unsigned int)jarg1;
45026   arg2 = (unsigned int)jarg2;
45027   arg3 = (Dali::Pixel::Format)jarg3;
45028   {
45029     try {
45030       result = Dali::BufferImage::New(arg1,arg2,arg3);
45031     } catch (std::out_of_range& e) {
45032       {
45033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45034       };
45035     } catch (std::exception& e) {
45036       {
45037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45038       };
45039     } catch (Dali::DaliException e) {
45040       {
45041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45042       };
45043     } catch (...) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45046       };
45047     }
45048   }
45049
45050   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45051   return jresult;
45052 }
45053
45054
45055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45056   void * jresult ;
45057   unsigned int arg1 ;
45058   unsigned int arg2 ;
45059   Dali::BufferImage result;
45060
45061   arg1 = (unsigned int)jarg1;
45062   arg2 = (unsigned int)jarg2;
45063   {
45064     try {
45065       result = Dali::BufferImage::New(arg1,arg2);
45066     } catch (std::out_of_range& e) {
45067       {
45068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45069       };
45070     } catch (std::exception& e) {
45071       {
45072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45073       };
45074     } catch (Dali::DaliException e) {
45075       {
45076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45077       };
45078     } catch (...) {
45079       {
45080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45081       };
45082     }
45083   }
45084
45085   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45086   return jresult;
45087 }
45088
45089
45090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45091   void * jresult ;
45092   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45093   unsigned int arg2 ;
45094   unsigned int arg3 ;
45095   Dali::Pixel::Format arg4 ;
45096   unsigned int arg5 ;
45097   Dali::BufferImage result;
45098
45099   arg1 = jarg1;
45100   arg2 = (unsigned int)jarg2;
45101   arg3 = (unsigned int)jarg3;
45102   arg4 = (Dali::Pixel::Format)jarg4;
45103   arg5 = (unsigned int)jarg5;
45104   {
45105     try {
45106       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45107     } catch (std::out_of_range& e) {
45108       {
45109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (std::exception& e) {
45112       {
45113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (Dali::DaliException e) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45118       };
45119     } catch (...) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45122       };
45123     }
45124   }
45125
45126   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45127
45128
45129   return jresult;
45130 }
45131
45132
45133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45134   void * jresult ;
45135   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45136   unsigned int arg2 ;
45137   unsigned int arg3 ;
45138   Dali::Pixel::Format arg4 ;
45139   Dali::BufferImage result;
45140
45141   arg1 = jarg1;
45142   arg2 = (unsigned int)jarg2;
45143   arg3 = (unsigned int)jarg3;
45144   arg4 = (Dali::Pixel::Format)jarg4;
45145   {
45146     try {
45147       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45148     } catch (std::out_of_range& e) {
45149       {
45150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45151       };
45152     } catch (std::exception& e) {
45153       {
45154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45155       };
45156     } catch (Dali::DaliException e) {
45157       {
45158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45159       };
45160     } catch (...) {
45161       {
45162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45163       };
45164     }
45165   }
45166
45167   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45168
45169
45170   return jresult;
45171 }
45172
45173
45174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45175   void * jresult ;
45176   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45177   unsigned int arg2 ;
45178   unsigned int arg3 ;
45179   Dali::BufferImage result;
45180
45181   arg1 = jarg1;
45182   arg2 = (unsigned int)jarg2;
45183   arg3 = (unsigned int)jarg3;
45184   {
45185     try {
45186       result = Dali::BufferImage::New(arg1,arg2,arg3);
45187     } catch (std::out_of_range& e) {
45188       {
45189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45190       };
45191     } catch (std::exception& e) {
45192       {
45193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (Dali::DaliException e) {
45196       {
45197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45198       };
45199     } catch (...) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45202       };
45203     }
45204   }
45205
45206   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45207
45208
45209   return jresult;
45210 }
45211
45212
45213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45214   void * jresult ;
45215   Dali::BaseHandle arg1 ;
45216   Dali::BaseHandle *argp1 ;
45217   Dali::BufferImage result;
45218
45219   argp1 = (Dali::BaseHandle *)jarg1;
45220   if (!argp1) {
45221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45222     return 0;
45223   }
45224   arg1 = *argp1;
45225   {
45226     try {
45227       result = Dali::BufferImage::DownCast(arg1);
45228     } catch (std::out_of_range& e) {
45229       {
45230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45231       };
45232     } catch (std::exception& e) {
45233       {
45234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (Dali::DaliException e) {
45237       {
45238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45239       };
45240     } catch (...) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45243       };
45244     }
45245   }
45246
45247   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45248   return jresult;
45249 }
45250
45251
45252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45253   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45254
45255   arg1 = (Dali::BufferImage *)jarg1;
45256   {
45257     try {
45258       delete arg1;
45259     } catch (std::out_of_range& e) {
45260       {
45261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45262       };
45263     } catch (std::exception& e) {
45264       {
45265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (Dali::DaliException e) {
45268       {
45269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45270       };
45271     } catch (...) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45274       };
45275     }
45276   }
45277
45278 }
45279
45280
45281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45282   void * jresult ;
45283   Dali::BufferImage *arg1 = 0 ;
45284   Dali::BufferImage *result = 0 ;
45285
45286   arg1 = (Dali::BufferImage *)jarg1;
45287   if (!arg1) {
45288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45289     return 0;
45290   }
45291   {
45292     try {
45293       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45294     } catch (std::out_of_range& e) {
45295       {
45296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45297       };
45298     } catch (std::exception& e) {
45299       {
45300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45301       };
45302     } catch (Dali::DaliException e) {
45303       {
45304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45305       };
45306     } catch (...) {
45307       {
45308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45309       };
45310     }
45311   }
45312
45313   jresult = (void *)result;
45314   return jresult;
45315 }
45316
45317
45318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45319   void * jresult ;
45320   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45321   Dali::BufferImage *arg2 = 0 ;
45322   Dali::BufferImage *result = 0 ;
45323
45324   arg1 = (Dali::BufferImage *)jarg1;
45325   arg2 = (Dali::BufferImage *)jarg2;
45326   if (!arg2) {
45327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45328     return 0;
45329   }
45330   {
45331     try {
45332       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45333     } catch (std::out_of_range& e) {
45334       {
45335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45336       };
45337     } catch (std::exception& e) {
45338       {
45339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (Dali::DaliException e) {
45342       {
45343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45344       };
45345     } catch (...) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45348       };
45349     }
45350   }
45351
45352   jresult = (void *)result;
45353   return jresult;
45354 }
45355
45356
45357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45358   void * jresult ;
45359   Dali::BufferImage result;
45360
45361   {
45362     try {
45363       result = Dali::BufferImage::WHITE();
45364     } catch (std::out_of_range& e) {
45365       {
45366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45367       };
45368     } catch (std::exception& e) {
45369       {
45370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45371       };
45372     } catch (Dali::DaliException e) {
45373       {
45374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45375       };
45376     } catch (...) {
45377       {
45378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45379       };
45380     }
45381   }
45382
45383   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45384   return jresult;
45385 }
45386
45387
45388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45389   void * jresult ;
45390   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45391   Dali::PixelBuffer *result = 0 ;
45392
45393   arg1 = (Dali::BufferImage *)jarg1;
45394   {
45395     try {
45396       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45397     } catch (std::out_of_range& e) {
45398       {
45399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45400       };
45401     } catch (std::exception& e) {
45402       {
45403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (Dali::DaliException e) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45408       };
45409     } catch (...) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45412       };
45413     }
45414   }
45415
45416   jresult = (void *)result;
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45422   unsigned int jresult ;
45423   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45424   unsigned int result;
45425
45426   arg1 = (Dali::BufferImage *)jarg1;
45427   {
45428     try {
45429       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45430     } catch (std::out_of_range& e) {
45431       {
45432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45433       };
45434     } catch (std::exception& e) {
45435       {
45436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (Dali::DaliException e) {
45439       {
45440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45441       };
45442     } catch (...) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45445       };
45446     }
45447   }
45448
45449   jresult = result;
45450   return jresult;
45451 }
45452
45453
45454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45455   unsigned int jresult ;
45456   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45457   unsigned int result;
45458
45459   arg1 = (Dali::BufferImage *)jarg1;
45460   {
45461     try {
45462       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45463     } catch (std::out_of_range& e) {
45464       {
45465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45466       };
45467     } catch (std::exception& e) {
45468       {
45469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (Dali::DaliException e) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45474       };
45475     } catch (...) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45478       };
45479     }
45480   }
45481
45482   jresult = result;
45483   return jresult;
45484 }
45485
45486
45487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45488   int jresult ;
45489   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45490   Dali::Pixel::Format result;
45491
45492   arg1 = (Dali::BufferImage *)jarg1;
45493   {
45494     try {
45495       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45496     } catch (std::out_of_range& e) {
45497       {
45498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45499       };
45500     } catch (std::exception& e) {
45501       {
45502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (Dali::DaliException e) {
45505       {
45506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45507       };
45508     } catch (...) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45511       };
45512     }
45513   }
45514
45515   jresult = (int)result;
45516   return jresult;
45517 }
45518
45519
45520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45521   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45522
45523   arg1 = (Dali::BufferImage *)jarg1;
45524   {
45525     try {
45526       (arg1)->Update();
45527     } catch (std::out_of_range& e) {
45528       {
45529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45530       };
45531     } catch (std::exception& e) {
45532       {
45533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45534       };
45535     } catch (Dali::DaliException e) {
45536       {
45537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45538       };
45539     } catch (...) {
45540       {
45541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45542       };
45543     }
45544   }
45545
45546 }
45547
45548
45549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45550   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45551   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45552   Dali::RectArea *argp2 ;
45553
45554   arg1 = (Dali::BufferImage *)jarg1;
45555   argp2 = (Dali::RectArea *)jarg2;
45556   if (!argp2) {
45557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45558     return ;
45559   }
45560   arg2 = *argp2;
45561   {
45562     try {
45563       (arg1)->Update(arg2);
45564     } catch (std::out_of_range& e) {
45565       {
45566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45567       };
45568     } catch (std::exception& e) {
45569       {
45570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45571       };
45572     } catch (Dali::DaliException e) {
45573       {
45574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45575       };
45576     } catch (...) {
45577       {
45578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45579       };
45580     }
45581   }
45582
45583 }
45584
45585
45586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45587   unsigned int jresult ;
45588   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45589   bool result;
45590
45591   arg1 = (Dali::BufferImage *)jarg1;
45592   {
45593     try {
45594       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45595     } catch (std::out_of_range& e) {
45596       {
45597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (std::exception& e) {
45600       {
45601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (Dali::DaliException e) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45606       };
45607     } catch (...) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45610       };
45611     }
45612   }
45613
45614   jresult = result;
45615   return jresult;
45616 }
45617
45618
45619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45620   void * jresult ;
45621   Dali::EncodedBufferImage *result = 0 ;
45622
45623   {
45624     try {
45625       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45626     } catch (std::out_of_range& e) {
45627       {
45628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45629       };
45630     } catch (std::exception& e) {
45631       {
45632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (Dali::DaliException e) {
45635       {
45636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45637       };
45638     } catch (...) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45641       };
45642     }
45643   }
45644
45645   jresult = (void *)result;
45646   return jresult;
45647 }
45648
45649
45650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45651   void * jresult ;
45652   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45653   std::size_t arg2 ;
45654   Dali::EncodedBufferImage result;
45655
45656   arg1 = (uint8_t *)jarg1;
45657   arg2 = (std::size_t)jarg2;
45658   {
45659     try {
45660       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45661     } catch (std::out_of_range& e) {
45662       {
45663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45664       };
45665     } catch (std::exception& e) {
45666       {
45667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (Dali::DaliException e) {
45670       {
45671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679
45680   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45681   return jresult;
45682 }
45683
45684
45685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45686   void * jresult ;
45687   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45688   std::size_t arg2 ;
45689   Dali::ImageDimensions arg3 ;
45690   Dali::FittingMode::Type arg4 ;
45691   Dali::SamplingMode::Type arg5 ;
45692   bool arg6 ;
45693   Dali::ImageDimensions *argp3 ;
45694   Dali::EncodedBufferImage result;
45695
45696   arg1 = (uint8_t *)jarg1;
45697   arg2 = (std::size_t)jarg2;
45698   argp3 = (Dali::ImageDimensions *)jarg3;
45699   if (!argp3) {
45700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45701     return 0;
45702   }
45703   arg3 = *argp3;
45704   arg4 = (Dali::FittingMode::Type)jarg4;
45705   arg5 = (Dali::SamplingMode::Type)jarg5;
45706   arg6 = jarg6 ? true : false;
45707   {
45708     try {
45709       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45710     } catch (std::out_of_range& e) {
45711       {
45712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45713       };
45714     } catch (std::exception& e) {
45715       {
45716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (Dali::DaliException e) {
45719       {
45720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45721       };
45722     } catch (...) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45725       };
45726     }
45727   }
45728
45729   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45730   return jresult;
45731 }
45732
45733
45734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45735   void * jresult ;
45736   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45737   std::size_t arg2 ;
45738   Dali::ImageDimensions arg3 ;
45739   Dali::FittingMode::Type arg4 ;
45740   Dali::SamplingMode::Type arg5 ;
45741   Dali::ImageDimensions *argp3 ;
45742   Dali::EncodedBufferImage result;
45743
45744   arg1 = (uint8_t *)jarg1;
45745   arg2 = (std::size_t)jarg2;
45746   argp3 = (Dali::ImageDimensions *)jarg3;
45747   if (!argp3) {
45748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45749     return 0;
45750   }
45751   arg3 = *argp3;
45752   arg4 = (Dali::FittingMode::Type)jarg4;
45753   arg5 = (Dali::SamplingMode::Type)jarg5;
45754   {
45755     try {
45756       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
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_DownCast(void * jarg1) {
45782   void * jresult ;
45783   Dali::BaseHandle arg1 ;
45784   Dali::BaseHandle *argp1 ;
45785   Dali::EncodedBufferImage result;
45786
45787   argp1 = (Dali::BaseHandle *)jarg1;
45788   if (!argp1) {
45789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45790     return 0;
45791   }
45792   arg1 = *argp1;
45793   {
45794     try {
45795       result = Dali::EncodedBufferImage::DownCast(arg1);
45796     } catch (std::out_of_range& e) {
45797       {
45798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45799       };
45800     } catch (std::exception& e) {
45801       {
45802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (Dali::DaliException e) {
45805       {
45806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45807       };
45808     } catch (...) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45811       };
45812     }
45813   }
45814
45815   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45821   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45822
45823   arg1 = (Dali::EncodedBufferImage *)jarg1;
45824   {
45825     try {
45826       delete arg1;
45827     } catch (std::out_of_range& e) {
45828       {
45829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45830       };
45831     } catch (std::exception& e) {
45832       {
45833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45834       };
45835     } catch (Dali::DaliException e) {
45836       {
45837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45838       };
45839     } catch (...) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45842       };
45843     }
45844   }
45845
45846 }
45847
45848
45849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45850   void * jresult ;
45851   Dali::EncodedBufferImage *arg1 = 0 ;
45852   Dali::EncodedBufferImage *result = 0 ;
45853
45854   arg1 = (Dali::EncodedBufferImage *)jarg1;
45855   if (!arg1) {
45856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45857     return 0;
45858   }
45859   {
45860     try {
45861       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45862     } catch (std::out_of_range& e) {
45863       {
45864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45865       };
45866     } catch (std::exception& e) {
45867       {
45868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (Dali::DaliException e) {
45871       {
45872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45873       };
45874     } catch (...) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45877       };
45878     }
45879   }
45880
45881   jresult = (void *)result;
45882   return jresult;
45883 }
45884
45885
45886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45887   void * jresult ;
45888   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45889   Dali::EncodedBufferImage *arg2 = 0 ;
45890   Dali::EncodedBufferImage *result = 0 ;
45891
45892   arg1 = (Dali::EncodedBufferImage *)jarg1;
45893   arg2 = (Dali::EncodedBufferImage *)jarg2;
45894   if (!arg2) {
45895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45896     return 0;
45897   }
45898   {
45899     try {
45900       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45901     } catch (std::out_of_range& e) {
45902       {
45903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45904       };
45905     } catch (std::exception& e) {
45906       {
45907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (Dali::DaliException e) {
45910       {
45911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45912       };
45913     } catch (...) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45916       };
45917     }
45918   }
45919
45920   jresult = (void *)result;
45921   return jresult;
45922 }
45923
45924
45925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45926   void * jresult ;
45927   Dali::NativeImage *result = 0 ;
45928
45929   {
45930     try {
45931       result = (Dali::NativeImage *)new Dali::NativeImage();
45932     } catch (std::out_of_range& e) {
45933       {
45934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45935       };
45936     } catch (std::exception& e) {
45937       {
45938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (Dali::DaliException e) {
45941       {
45942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45943       };
45944     } catch (...) {
45945       {
45946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45947       };
45948     }
45949   }
45950
45951   jresult = (void *)result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45957   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45958
45959   arg1 = (Dali::NativeImage *)jarg1;
45960   {
45961     try {
45962       delete arg1;
45963     } catch (std::out_of_range& e) {
45964       {
45965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45966       };
45967     } catch (std::exception& e) {
45968       {
45969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45970       };
45971     } catch (Dali::DaliException e) {
45972       {
45973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45974       };
45975     } catch (...) {
45976       {
45977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45978       };
45979     }
45980   }
45981
45982 }
45983
45984
45985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45986   void * jresult ;
45987   Dali::NativeImage *arg1 = 0 ;
45988   Dali::NativeImage *result = 0 ;
45989
45990   arg1 = (Dali::NativeImage *)jarg1;
45991   if (!arg1) {
45992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45993     return 0;
45994   }
45995   {
45996     try {
45997       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45998     } catch (std::out_of_range& e) {
45999       {
46000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46001       };
46002     } catch (std::exception& e) {
46003       {
46004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (Dali::DaliException e) {
46007       {
46008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46009       };
46010     } catch (...) {
46011       {
46012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46013       };
46014     }
46015   }
46016
46017   jresult = (void *)result;
46018   return jresult;
46019 }
46020
46021
46022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46023   void * jresult ;
46024   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46025   Dali::NativeImage *arg2 = 0 ;
46026   Dali::NativeImage *result = 0 ;
46027
46028   arg1 = (Dali::NativeImage *)jarg1;
46029   arg2 = (Dali::NativeImage *)jarg2;
46030   if (!arg2) {
46031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46032     return 0;
46033   }
46034   {
46035     try {
46036       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46037     } catch (std::out_of_range& e) {
46038       {
46039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (std::exception& e) {
46042       {
46043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (Dali::DaliException e) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46048       };
46049     } catch (...) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46052       };
46053     }
46054   }
46055
46056   jresult = (void *)result;
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46062   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46063
46064   arg1 = (Dali::NativeImage *)jarg1;
46065   {
46066     try {
46067       (arg1)->CreateGlTexture();
46068     } catch (std::out_of_range& e) {
46069       {
46070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46071       };
46072     } catch (std::exception& e) {
46073       {
46074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46075       };
46076     } catch (Dali::DaliException e) {
46077       {
46078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46079       };
46080     } catch (...) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46083       };
46084     }
46085   }
46086
46087 }
46088
46089
46090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46091   void * jresult ;
46092   NativeImageInterface *arg1 = 0 ;
46093   Dali::NativeImage result;
46094
46095   arg1 = (NativeImageInterface *)jarg1;
46096   if (!arg1) {
46097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46098     return 0;
46099   }
46100   {
46101     try {
46102       result = Dali::NativeImage::New(*arg1);
46103     } catch (std::out_of_range& e) {
46104       {
46105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46106       };
46107     } catch (std::exception& e) {
46108       {
46109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46110       };
46111     } catch (Dali::DaliException e) {
46112       {
46113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46114       };
46115     } catch (...) {
46116       {
46117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46118       };
46119     }
46120   }
46121
46122   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46123   return jresult;
46124 }
46125
46126
46127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46128   void * jresult ;
46129   Dali::BaseHandle arg1 ;
46130   Dali::BaseHandle *argp1 ;
46131   Dali::NativeImage result;
46132
46133   argp1 = (Dali::BaseHandle *)jarg1;
46134   if (!argp1) {
46135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46136     return 0;
46137   }
46138   arg1 = *argp1;
46139   {
46140     try {
46141       result = Dali::NativeImage::DownCast(arg1);
46142     } catch (std::out_of_range& e) {
46143       {
46144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46145       };
46146     } catch (std::exception& e) {
46147       {
46148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46149       };
46150     } catch (Dali::DaliException e) {
46151       {
46152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46153       };
46154     } catch (...) {
46155       {
46156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46157       };
46158     }
46159   }
46160
46161   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46162   return jresult;
46163 }
46164
46165
46166 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46167   char * jresult ;
46168   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46169   char *result = 0 ;
46170
46171   arg1 = (Dali::NativeImage *)jarg1;
46172   {
46173     try {
46174       result = (char *)(arg1)->GetCustomFragmentPreFix();
46175     } catch (std::out_of_range& e) {
46176       {
46177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46178       };
46179     } catch (std::exception& e) {
46180       {
46181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (Dali::DaliException e) {
46184       {
46185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46186       };
46187     } catch (...) {
46188       {
46189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46190       };
46191     }
46192   }
46193
46194   jresult = SWIG_csharp_string_callback((const char *)result);
46195   return jresult;
46196 }
46197
46198
46199 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46200   char * jresult ;
46201   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46202   char *result = 0 ;
46203
46204   arg1 = (Dali::NativeImage *)jarg1;
46205   {
46206     try {
46207       result = (char *)(arg1)->GetCustomSamplerTypename();
46208     } catch (std::out_of_range& e) {
46209       {
46210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46211       };
46212     } catch (std::exception& e) {
46213       {
46214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (Dali::DaliException e) {
46217       {
46218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46219       };
46220     } catch (...) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46223       };
46224     }
46225   }
46226
46227   jresult = SWIG_csharp_string_callback((const char *)result);
46228   return jresult;
46229 }
46230
46231
46232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46233   unsigned int jresult ;
46234   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46235   bool result;
46236
46237   arg1 = (Dali::NativeImageInterface *)jarg1;
46238   {
46239     try {
46240       result = (bool)(arg1)->GlExtensionCreate();
46241     } catch (std::out_of_range& e) {
46242       {
46243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46244       };
46245     } catch (std::exception& e) {
46246       {
46247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (Dali::DaliException e) {
46250       {
46251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46252       };
46253     } catch (...) {
46254       {
46255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46256       };
46257     }
46258   }
46259
46260   jresult = result;
46261   return jresult;
46262 }
46263
46264
46265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46266   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46267
46268   arg1 = (Dali::NativeImageInterface *)jarg1;
46269   {
46270     try {
46271       (arg1)->GlExtensionDestroy();
46272     } catch (std::out_of_range& e) {
46273       {
46274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46275       };
46276     } catch (std::exception& e) {
46277       {
46278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46279       };
46280     } catch (Dali::DaliException e) {
46281       {
46282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46287       };
46288     }
46289   }
46290
46291 }
46292
46293
46294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46295   unsigned int jresult ;
46296   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46297   unsigned int result;
46298
46299   arg1 = (Dali::NativeImageInterface *)jarg1;
46300   {
46301     try {
46302       result = (unsigned int)(arg1)->TargetTexture();
46303     } catch (std::out_of_range& e) {
46304       {
46305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46306       };
46307     } catch (std::exception& e) {
46308       {
46309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (Dali::DaliException e) {
46312       {
46313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46314       };
46315     } catch (...) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46318       };
46319     }
46320   }
46321
46322   jresult = result;
46323   return jresult;
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46328   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46329
46330   arg1 = (Dali::NativeImageInterface *)jarg1;
46331   {
46332     try {
46333       (arg1)->PrepareTexture();
46334     } catch (std::out_of_range& e) {
46335       {
46336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46337       };
46338     } catch (std::exception& e) {
46339       {
46340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46341       };
46342     } catch (Dali::DaliException e) {
46343       {
46344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46345       };
46346     } catch (...) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46349       };
46350     }
46351   }
46352
46353 }
46354
46355
46356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46357   unsigned int jresult ;
46358   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46359   unsigned int result;
46360
46361   arg1 = (Dali::NativeImageInterface *)jarg1;
46362   {
46363     try {
46364       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46365     } catch (std::out_of_range& e) {
46366       {
46367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46368       };
46369     } catch (std::exception& e) {
46370       {
46371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (Dali::DaliException e) {
46374       {
46375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46376       };
46377     } catch (...) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46380       };
46381     }
46382   }
46383
46384   jresult = result;
46385   return jresult;
46386 }
46387
46388
46389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46390   unsigned int jresult ;
46391   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46392   unsigned int result;
46393
46394   arg1 = (Dali::NativeImageInterface *)jarg1;
46395   {
46396     try {
46397       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (Dali::DaliException e) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46413       };
46414     }
46415   }
46416
46417   jresult = result;
46418   return jresult;
46419 }
46420
46421
46422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46423   unsigned int jresult ;
46424   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46425   bool result;
46426
46427   arg1 = (Dali::NativeImageInterface *)jarg1;
46428   {
46429     try {
46430       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46431     } catch (std::out_of_range& e) {
46432       {
46433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46434       };
46435     } catch (std::exception& e) {
46436       {
46437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46438       };
46439     } catch (Dali::DaliException e) {
46440       {
46441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46442       };
46443     } catch (...) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46446       };
46447     }
46448   }
46449
46450   jresult = result;
46451   return jresult;
46452 }
46453
46454
46455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46456   void * jresult ;
46457   std::string *arg1 = 0 ;
46458   Dali::ImageDimensions result;
46459
46460   if (!jarg1) {
46461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46462     return 0;
46463   }
46464   std::string arg1_str(jarg1);
46465   arg1 = &arg1_str;
46466   {
46467     try {
46468       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46469     } catch (std::out_of_range& e) {
46470       {
46471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (std::exception& e) {
46474       {
46475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (Dali::DaliException e) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46480       };
46481     } catch (...) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46484       };
46485     }
46486   }
46487
46488   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46489
46490   //argout typemap for const std::string&
46491
46492   return jresult;
46493 }
46494
46495
46496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46497   void * jresult ;
46498   Dali::ResourceImage *result = 0 ;
46499
46500   {
46501     try {
46502       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46503     } catch (std::out_of_range& e) {
46504       {
46505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46506       };
46507     } catch (std::exception& e) {
46508       {
46509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46510       };
46511     } catch (Dali::DaliException e) {
46512       {
46513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46514       };
46515     } catch (...) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46518       };
46519     }
46520   }
46521
46522   jresult = (void *)result;
46523   return jresult;
46524 }
46525
46526
46527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46528   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46529
46530   arg1 = (Dali::ResourceImage *)jarg1;
46531   {
46532     try {
46533       delete arg1;
46534     } catch (std::out_of_range& e) {
46535       {
46536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46537       };
46538     } catch (std::exception& e) {
46539       {
46540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46541       };
46542     } catch (Dali::DaliException e) {
46543       {
46544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46545       };
46546     } catch (...) {
46547       {
46548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46549       };
46550     }
46551   }
46552
46553 }
46554
46555
46556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46557   void * jresult ;
46558   Dali::ResourceImage *arg1 = 0 ;
46559   Dali::ResourceImage *result = 0 ;
46560
46561   arg1 = (Dali::ResourceImage *)jarg1;
46562   if (!arg1) {
46563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46564     return 0;
46565   }
46566   {
46567     try {
46568       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46569     } catch (std::out_of_range& e) {
46570       {
46571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46572       };
46573     } catch (std::exception& e) {
46574       {
46575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46576       };
46577     } catch (Dali::DaliException e) {
46578       {
46579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46580       };
46581     } catch (...) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46584       };
46585     }
46586   }
46587
46588   jresult = (void *)result;
46589   return jresult;
46590 }
46591
46592
46593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46594   void * jresult ;
46595   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46596   Dali::ResourceImage *arg2 = 0 ;
46597   Dali::ResourceImage *result = 0 ;
46598
46599   arg1 = (Dali::ResourceImage *)jarg1;
46600   arg2 = (Dali::ResourceImage *)jarg2;
46601   if (!arg2) {
46602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46603     return 0;
46604   }
46605   {
46606     try {
46607       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46608     } catch (std::out_of_range& e) {
46609       {
46610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46611       };
46612     } catch (std::exception& e) {
46613       {
46614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46615       };
46616     } catch (Dali::DaliException e) {
46617       {
46618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46619       };
46620     } catch (...) {
46621       {
46622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46623       };
46624     }
46625   }
46626
46627   jresult = (void *)result;
46628   return jresult;
46629 }
46630
46631
46632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46633   void * jresult ;
46634   std::string *arg1 = 0 ;
46635   bool arg2 ;
46636   Dali::ResourceImage result;
46637
46638   if (!jarg1) {
46639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46640     return 0;
46641   }
46642   std::string arg1_str(jarg1);
46643   arg1 = &arg1_str;
46644   arg2 = jarg2 ? true : false;
46645   {
46646     try {
46647       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46648     } catch (std::out_of_range& e) {
46649       {
46650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46651       };
46652     } catch (std::exception& e) {
46653       {
46654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46655       };
46656     } catch (Dali::DaliException e) {
46657       {
46658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46659       };
46660     } catch (...) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46663       };
46664     }
46665   }
46666
46667   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46668
46669   //argout typemap for const std::string&
46670
46671   return jresult;
46672 }
46673
46674
46675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46676   void * jresult ;
46677   std::string *arg1 = 0 ;
46678   Dali::ResourceImage result;
46679
46680   if (!jarg1) {
46681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46682     return 0;
46683   }
46684   std::string arg1_str(jarg1);
46685   arg1 = &arg1_str;
46686   {
46687     try {
46688       result = Dali::ResourceImage::New((std::string const &)*arg1);
46689     } catch (std::out_of_range& e) {
46690       {
46691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46692       };
46693     } catch (std::exception& e) {
46694       {
46695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (Dali::DaliException e) {
46698       {
46699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46700       };
46701     } catch (...) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46704       };
46705     }
46706   }
46707
46708   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46709
46710   //argout typemap for const std::string&
46711
46712   return jresult;
46713 }
46714
46715
46716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46717   void * jresult ;
46718   std::string *arg1 = 0 ;
46719   Dali::ImageDimensions arg2 ;
46720   Dali::FittingMode::Type arg3 ;
46721   Dali::SamplingMode::Type arg4 ;
46722   bool arg5 ;
46723   Dali::ImageDimensions *argp2 ;
46724   Dali::ResourceImage result;
46725
46726   if (!jarg1) {
46727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46728     return 0;
46729   }
46730   std::string arg1_str(jarg1);
46731   arg1 = &arg1_str;
46732   argp2 = (Dali::ImageDimensions *)jarg2;
46733   if (!argp2) {
46734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46735     return 0;
46736   }
46737   arg2 = *argp2;
46738   arg3 = (Dali::FittingMode::Type)jarg3;
46739   arg4 = (Dali::SamplingMode::Type)jarg4;
46740   arg5 = jarg5 ? true : false;
46741   {
46742     try {
46743       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
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_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46772   void * jresult ;
46773   std::string *arg1 = 0 ;
46774   Dali::ImageDimensions arg2 ;
46775   Dali::FittingMode::Type arg3 ;
46776   Dali::SamplingMode::Type arg4 ;
46777   Dali::ImageDimensions *argp2 ;
46778   Dali::ResourceImage result;
46779
46780   if (!jarg1) {
46781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46782     return 0;
46783   }
46784   std::string arg1_str(jarg1);
46785   arg1 = &arg1_str;
46786   argp2 = (Dali::ImageDimensions *)jarg2;
46787   if (!argp2) {
46788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46789     return 0;
46790   }
46791   arg2 = *argp2;
46792   arg3 = (Dali::FittingMode::Type)jarg3;
46793   arg4 = (Dali::SamplingMode::Type)jarg4;
46794   {
46795     try {
46796       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46797     } catch (std::out_of_range& e) {
46798       {
46799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (std::exception& e) {
46802       {
46803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (Dali::DaliException e) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46812       };
46813     }
46814   }
46815
46816   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46817
46818   //argout typemap for const std::string&
46819
46820   return jresult;
46821 }
46822
46823
46824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46825   void * jresult ;
46826   std::string *arg1 = 0 ;
46827   Dali::ImageDimensions arg2 ;
46828   Dali::FittingMode::Type arg3 ;
46829   Dali::ImageDimensions *argp2 ;
46830   Dali::ResourceImage result;
46831
46832   if (!jarg1) {
46833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46834     return 0;
46835   }
46836   std::string arg1_str(jarg1);
46837   arg1 = &arg1_str;
46838   argp2 = (Dali::ImageDimensions *)jarg2;
46839   if (!argp2) {
46840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46841     return 0;
46842   }
46843   arg2 = *argp2;
46844   arg3 = (Dali::FittingMode::Type)jarg3;
46845   {
46846     try {
46847       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46848     } catch (std::out_of_range& e) {
46849       {
46850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46851       };
46852     } catch (std::exception& e) {
46853       {
46854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (Dali::DaliException e) {
46857       {
46858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46859       };
46860     } catch (...) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46863       };
46864     }
46865   }
46866
46867   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46868
46869   //argout typemap for const std::string&
46870
46871   return jresult;
46872 }
46873
46874
46875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46876   void * jresult ;
46877   std::string *arg1 = 0 ;
46878   Dali::ImageDimensions arg2 ;
46879   Dali::ImageDimensions *argp2 ;
46880   Dali::ResourceImage result;
46881
46882   if (!jarg1) {
46883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46884     return 0;
46885   }
46886   std::string arg1_str(jarg1);
46887   arg1 = &arg1_str;
46888   argp2 = (Dali::ImageDimensions *)jarg2;
46889   if (!argp2) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46891     return 0;
46892   }
46893   arg2 = *argp2;
46894   {
46895     try {
46896       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46897     } catch (std::out_of_range& e) {
46898       {
46899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46900       };
46901     } catch (std::exception& e) {
46902       {
46903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (Dali::DaliException e) {
46906       {
46907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46908       };
46909     } catch (...) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46912       };
46913     }
46914   }
46915
46916   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46917
46918   //argout typemap for const std::string&
46919
46920   return jresult;
46921 }
46922
46923
46924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46925   void * jresult ;
46926   Dali::BaseHandle arg1 ;
46927   Dali::BaseHandle *argp1 ;
46928   Dali::ResourceImage result;
46929
46930   argp1 = (Dali::BaseHandle *)jarg1;
46931   if (!argp1) {
46932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46933     return 0;
46934   }
46935   arg1 = *argp1;
46936   {
46937     try {
46938       result = Dali::ResourceImage::DownCast(arg1);
46939     } catch (std::out_of_range& e) {
46940       {
46941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46942       };
46943     } catch (std::exception& e) {
46944       {
46945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46946       };
46947     } catch (Dali::DaliException e) {
46948       {
46949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46950       };
46951     } catch (...) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46954       };
46955     }
46956   }
46957
46958   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46959   return jresult;
46960 }
46961
46962
46963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46964   int jresult ;
46965   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46966   Dali::LoadingState result;
46967
46968   arg1 = (Dali::ResourceImage *)jarg1;
46969   {
46970     try {
46971       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46972     } catch (std::out_of_range& e) {
46973       {
46974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46975       };
46976     } catch (std::exception& e) {
46977       {
46978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46979       };
46980     } catch (Dali::DaliException e) {
46981       {
46982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46983       };
46984     } catch (...) {
46985       {
46986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46987       };
46988     }
46989   }
46990
46991   jresult = (int)result;
46992   return jresult;
46993 }
46994
46995
46996 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46997   char * jresult ;
46998   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46999   std::string result;
47000
47001   arg1 = (Dali::ResourceImage *)jarg1;
47002   {
47003     try {
47004       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47005     } catch (std::out_of_range& e) {
47006       {
47007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47008       };
47009     } catch (std::exception& e) {
47010       {
47011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (Dali::DaliException e) {
47014       {
47015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47016       };
47017     } catch (...) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47020       };
47021     }
47022   }
47023
47024   jresult = SWIG_csharp_string_callback((&result)->c_str());
47025   return jresult;
47026 }
47027
47028
47029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47030   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47031
47032   arg1 = (Dali::ResourceImage *)jarg1;
47033   {
47034     try {
47035       (arg1)->Reload();
47036     } catch (std::out_of_range& e) {
47037       {
47038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47039       };
47040     } catch (std::exception& e) {
47041       {
47042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (Dali::DaliException e) {
47045       {
47046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47047       };
47048     } catch (...) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47051       };
47052     }
47053   }
47054
47055 }
47056
47057
47058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47059   void * jresult ;
47060   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47061   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47062
47063   arg1 = (Dali::ResourceImage *)jarg1;
47064   {
47065     try {
47066       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47067     } catch (std::out_of_range& e) {
47068       {
47069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47070       };
47071     } catch (std::exception& e) {
47072       {
47073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (Dali::DaliException e) {
47076       {
47077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47078       };
47079     } catch (...) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47082       };
47083     }
47084   }
47085
47086   jresult = (void *)result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47092   void * jresult ;
47093   Dali::FrameBufferImage *result = 0 ;
47094
47095   {
47096     try {
47097       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47098     } catch (std::out_of_range& e) {
47099       {
47100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47101       };
47102     } catch (std::exception& e) {
47103       {
47104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (Dali::DaliException e) {
47107       {
47108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47109       };
47110     } catch (...) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47113       };
47114     }
47115   }
47116
47117   jresult = (void *)result;
47118   return jresult;
47119 }
47120
47121
47122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47123   void * jresult ;
47124   unsigned int arg1 ;
47125   unsigned int arg2 ;
47126   Dali::Pixel::Format arg3 ;
47127   Dali::RenderBuffer::Format arg4 ;
47128   Dali::FrameBufferImage result;
47129
47130   arg1 = (unsigned int)jarg1;
47131   arg2 = (unsigned int)jarg2;
47132   arg3 = (Dali::Pixel::Format)jarg3;
47133   arg4 = (Dali::RenderBuffer::Format)jarg4;
47134   {
47135     try {
47136       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47137     } catch (std::out_of_range& e) {
47138       {
47139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47140       };
47141     } catch (std::exception& e) {
47142       {
47143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (Dali::DaliException e) {
47146       {
47147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47152       };
47153     }
47154   }
47155
47156   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47157   return jresult;
47158 }
47159
47160
47161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47162   void * jresult ;
47163   unsigned int arg1 ;
47164   unsigned int arg2 ;
47165   Dali::Pixel::Format arg3 ;
47166   Dali::FrameBufferImage result;
47167
47168   arg1 = (unsigned int)jarg1;
47169   arg2 = (unsigned int)jarg2;
47170   arg3 = (Dali::Pixel::Format)jarg3;
47171   {
47172     try {
47173       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47174     } catch (std::out_of_range& e) {
47175       {
47176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47177       };
47178     } catch (std::exception& e) {
47179       {
47180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (Dali::DaliException e) {
47183       {
47184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47185       };
47186     } catch (...) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47189       };
47190     }
47191   }
47192
47193   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47194   return jresult;
47195 }
47196
47197
47198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47199   void * jresult ;
47200   unsigned int arg1 ;
47201   unsigned int arg2 ;
47202   Dali::FrameBufferImage result;
47203
47204   arg1 = (unsigned int)jarg1;
47205   arg2 = (unsigned int)jarg2;
47206   {
47207     try {
47208       result = Dali::FrameBufferImage::New(arg1,arg2);
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (Dali::DaliException e) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47224       };
47225     }
47226   }
47227
47228   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47229   return jresult;
47230 }
47231
47232
47233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47234   void * jresult ;
47235   unsigned int arg1 ;
47236   Dali::FrameBufferImage result;
47237
47238   arg1 = (unsigned int)jarg1;
47239   {
47240     try {
47241       result = Dali::FrameBufferImage::New(arg1);
47242     } catch (std::out_of_range& e) {
47243       {
47244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (std::exception& e) {
47247       {
47248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (Dali::DaliException e) {
47251       {
47252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47253       };
47254     } catch (...) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47257       };
47258     }
47259   }
47260
47261   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47262   return jresult;
47263 }
47264
47265
47266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47267   void * jresult ;
47268   Dali::FrameBufferImage result;
47269
47270   {
47271     try {
47272       result = Dali::FrameBufferImage::New();
47273     } catch (std::out_of_range& e) {
47274       {
47275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47276       };
47277     } catch (std::exception& e) {
47278       {
47279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47280       };
47281     } catch (Dali::DaliException e) {
47282       {
47283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47284       };
47285     } catch (...) {
47286       {
47287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47288       };
47289     }
47290   }
47291
47292   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47293   return jresult;
47294 }
47295
47296
47297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47298   void * jresult ;
47299   Dali::NativeImageInterface *arg1 = 0 ;
47300   Dali::FrameBufferImage result;
47301
47302   arg1 = (Dali::NativeImageInterface *)jarg1;
47303   if (!arg1) {
47304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47305     return 0;
47306   }
47307   {
47308     try {
47309       result = Dali::FrameBufferImage::New(*arg1);
47310     } catch (std::out_of_range& e) {
47311       {
47312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47313       };
47314     } catch (std::exception& e) {
47315       {
47316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (Dali::DaliException e) {
47319       {
47320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47321       };
47322     } catch (...) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47325       };
47326     }
47327   }
47328
47329   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47330   return jresult;
47331 }
47332
47333
47334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47335   void * jresult ;
47336   Dali::BaseHandle arg1 ;
47337   Dali::BaseHandle *argp1 ;
47338   Dali::FrameBufferImage result;
47339
47340   argp1 = (Dali::BaseHandle *)jarg1;
47341   if (!argp1) {
47342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47343     return 0;
47344   }
47345   arg1 = *argp1;
47346   {
47347     try {
47348       result = Dali::FrameBufferImage::DownCast(arg1);
47349     } catch (std::out_of_range& e) {
47350       {
47351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47352       };
47353     } catch (std::exception& e) {
47354       {
47355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (Dali::DaliException e) {
47358       {
47359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47360       };
47361     } catch (...) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47364       };
47365     }
47366   }
47367
47368   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47369   return jresult;
47370 }
47371
47372
47373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47374   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47375
47376   arg1 = (Dali::FrameBufferImage *)jarg1;
47377   {
47378     try {
47379       delete arg1;
47380     } catch (std::out_of_range& e) {
47381       {
47382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47383       };
47384     } catch (std::exception& e) {
47385       {
47386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (Dali::DaliException e) {
47389       {
47390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47391       };
47392     } catch (...) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47395       };
47396     }
47397   }
47398
47399 }
47400
47401
47402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47403   void * jresult ;
47404   Dali::FrameBufferImage *arg1 = 0 ;
47405   Dali::FrameBufferImage *result = 0 ;
47406
47407   arg1 = (Dali::FrameBufferImage *)jarg1;
47408   if (!arg1) {
47409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47410     return 0;
47411   }
47412   {
47413     try {
47414       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47415     } catch (std::out_of_range& e) {
47416       {
47417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47418       };
47419     } catch (std::exception& e) {
47420       {
47421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (Dali::DaliException e) {
47424       {
47425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47426       };
47427     } catch (...) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47430       };
47431     }
47432   }
47433
47434   jresult = (void *)result;
47435   return jresult;
47436 }
47437
47438
47439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47440   void * jresult ;
47441   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47442   Dali::FrameBufferImage *arg2 = 0 ;
47443   Dali::FrameBufferImage *result = 0 ;
47444
47445   arg1 = (Dali::FrameBufferImage *)jarg1;
47446   arg2 = (Dali::FrameBufferImage *)jarg2;
47447   if (!arg2) {
47448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47449     return 0;
47450   }
47451   {
47452     try {
47453       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47454     } catch (std::out_of_range& e) {
47455       {
47456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47457       };
47458     } catch (std::exception& e) {
47459       {
47460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (Dali::DaliException e) {
47463       {
47464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47465       };
47466     } catch (...) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47469       };
47470     }
47471   }
47472
47473   jresult = (void *)result;
47474   return jresult;
47475 }
47476
47477
47478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47479   void * jresult ;
47480   Dali::NinePatchImage *result = 0 ;
47481
47482   {
47483     try {
47484       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47485     } catch (std::out_of_range& e) {
47486       {
47487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47488       };
47489     } catch (std::exception& e) {
47490       {
47491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47492       };
47493     } catch (Dali::DaliException e) {
47494       {
47495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47496       };
47497     } catch (...) {
47498       {
47499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47500       };
47501     }
47502   }
47503
47504   jresult = (void *)result;
47505   return jresult;
47506 }
47507
47508
47509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47510   void * jresult ;
47511   std::string *arg1 = 0 ;
47512   Dali::NinePatchImage result;
47513
47514   if (!jarg1) {
47515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47516     return 0;
47517   }
47518   std::string arg1_str(jarg1);
47519   arg1 = &arg1_str;
47520   {
47521     try {
47522       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47530       };
47531     } catch (Dali::DaliException e) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47538       };
47539     }
47540   }
47541
47542   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47543
47544   //argout typemap for const std::string&
47545
47546   return jresult;
47547 }
47548
47549
47550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47551   void * jresult ;
47552   Dali::BaseHandle arg1 ;
47553   Dali::BaseHandle *argp1 ;
47554   Dali::NinePatchImage result;
47555
47556   argp1 = (Dali::BaseHandle *)jarg1;
47557   if (!argp1) {
47558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47559     return 0;
47560   }
47561   arg1 = *argp1;
47562   {
47563     try {
47564       result = Dali::NinePatchImage::DownCast(arg1);
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (Dali::DaliException e) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47576       };
47577     } catch (...) {
47578       {
47579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47580       };
47581     }
47582   }
47583
47584   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47585   return jresult;
47586 }
47587
47588
47589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47590   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47591
47592   arg1 = (Dali::NinePatchImage *)jarg1;
47593   {
47594     try {
47595       delete arg1;
47596     } catch (std::out_of_range& e) {
47597       {
47598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47599       };
47600     } catch (std::exception& e) {
47601       {
47602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47603       };
47604     } catch (Dali::DaliException e) {
47605       {
47606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47607       };
47608     } catch (...) {
47609       {
47610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47611       };
47612     }
47613   }
47614
47615 }
47616
47617
47618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47619   void * jresult ;
47620   Dali::NinePatchImage *arg1 = 0 ;
47621   Dali::NinePatchImage *result = 0 ;
47622
47623   arg1 = (Dali::NinePatchImage *)jarg1;
47624   if (!arg1) {
47625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47626     return 0;
47627   }
47628   {
47629     try {
47630       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47631     } catch (std::out_of_range& e) {
47632       {
47633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47634       };
47635     } catch (std::exception& e) {
47636       {
47637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (Dali::DaliException e) {
47640       {
47641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47642       };
47643     } catch (...) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47646       };
47647     }
47648   }
47649
47650   jresult = (void *)result;
47651   return jresult;
47652 }
47653
47654
47655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47656   void * jresult ;
47657   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47658   Dali::NinePatchImage *arg2 = 0 ;
47659   Dali::NinePatchImage *result = 0 ;
47660
47661   arg1 = (Dali::NinePatchImage *)jarg1;
47662   arg2 = (Dali::NinePatchImage *)jarg2;
47663   if (!arg2) {
47664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47665     return 0;
47666   }
47667   {
47668     try {
47669       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47670     } catch (std::out_of_range& e) {
47671       {
47672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47673       };
47674     } catch (std::exception& e) {
47675       {
47676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47677       };
47678     } catch (Dali::DaliException e) {
47679       {
47680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47681       };
47682     } catch (...) {
47683       {
47684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47685       };
47686     }
47687   }
47688
47689   jresult = (void *)result;
47690   return jresult;
47691 }
47692
47693
47694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47695   void * jresult ;
47696   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47697   Dali::Vector4 result;
47698
47699   arg1 = (Dali::NinePatchImage *)jarg1;
47700   {
47701     try {
47702       result = (arg1)->GetStretchBorders();
47703     } catch (std::out_of_range& e) {
47704       {
47705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47706       };
47707     } catch (std::exception& e) {
47708       {
47709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (Dali::DaliException e) {
47712       {
47713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47714       };
47715     } catch (...) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47718       };
47719     }
47720   }
47721
47722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47723   return jresult;
47724 }
47725
47726
47727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47728   void * jresult ;
47729   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47730   Dali::NinePatchImage::StretchRanges *result = 0 ;
47731
47732   arg1 = (Dali::NinePatchImage *)jarg1;
47733   {
47734     try {
47735       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47736     } catch (std::out_of_range& e) {
47737       {
47738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47739       };
47740     } catch (std::exception& e) {
47741       {
47742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (Dali::DaliException e) {
47745       {
47746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47747       };
47748     } catch (...) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47751       };
47752     }
47753   }
47754
47755   jresult = (void *)result;
47756   return jresult;
47757 }
47758
47759
47760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47761   void * jresult ;
47762   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47763   Dali::NinePatchImage::StretchRanges *result = 0 ;
47764
47765   arg1 = (Dali::NinePatchImage *)jarg1;
47766   {
47767     try {
47768       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47769     } catch (std::out_of_range& e) {
47770       {
47771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47772       };
47773     } catch (std::exception& e) {
47774       {
47775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (Dali::DaliException e) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47780       };
47781     } catch (...) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47784       };
47785     }
47786   }
47787
47788   jresult = (void *)result;
47789   return jresult;
47790 }
47791
47792
47793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47794   void * jresult ;
47795   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47796   Dali::Rect< int > result;
47797
47798   arg1 = (Dali::NinePatchImage *)jarg1;
47799   {
47800     try {
47801       result = (arg1)->GetChildRectangle();
47802     } catch (std::out_of_range& e) {
47803       {
47804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47805       };
47806     } catch (std::exception& e) {
47807       {
47808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47809       };
47810     } catch (Dali::DaliException e) {
47811       {
47812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47813       };
47814     } catch (...) {
47815       {
47816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47817       };
47818     }
47819   }
47820
47821   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47822   return jresult;
47823 }
47824
47825
47826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47827   void * jresult ;
47828   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47829   Dali::BufferImage result;
47830
47831   arg1 = (Dali::NinePatchImage *)jarg1;
47832   {
47833     try {
47834       result = (arg1)->CreateCroppedBufferImage();
47835     } catch (std::out_of_range& e) {
47836       {
47837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47838       };
47839     } catch (std::exception& e) {
47840       {
47841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (Dali::DaliException e) {
47844       {
47845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47846       };
47847     } catch (...) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47850       };
47851     }
47852   }
47853
47854   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47855   return jresult;
47856 }
47857
47858
47859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47860   unsigned int jresult ;
47861   std::string *arg1 = 0 ;
47862   bool result;
47863
47864   if (!jarg1) {
47865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47866     return 0;
47867   }
47868   std::string arg1_str(jarg1);
47869   arg1 = &arg1_str;
47870   {
47871     try {
47872       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (Dali::DaliException e) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47884       };
47885     } catch (...) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47888       };
47889     }
47890   }
47891
47892   jresult = result;
47893
47894   //argout typemap for const std::string&
47895
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47901   int jresult ;
47902   int result;
47903
47904   result = (int)Dali::CameraActor::Property::TYPE;
47905   jresult = (int)result;
47906   return jresult;
47907 }
47908
47909
47910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47911   int jresult ;
47912   int result;
47913
47914   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47915   jresult = (int)result;
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47921   int jresult ;
47922   int result;
47923
47924   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47925   jresult = (int)result;
47926   return jresult;
47927 }
47928
47929
47930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47931   int jresult ;
47932   int result;
47933
47934   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47935   jresult = (int)result;
47936   return jresult;
47937 }
47938
47939
47940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47941   int jresult ;
47942   int result;
47943
47944   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47945   jresult = (int)result;
47946   return jresult;
47947 }
47948
47949
47950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47951   int jresult ;
47952   int result;
47953
47954   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47955   jresult = (int)result;
47956   return jresult;
47957 }
47958
47959
47960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47961   int jresult ;
47962   int result;
47963
47964   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47965   jresult = (int)result;
47966   return jresult;
47967 }
47968
47969
47970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47971   int jresult ;
47972   int result;
47973
47974   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47975   jresult = (int)result;
47976   return jresult;
47977 }
47978
47979
47980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47981   int jresult ;
47982   int result;
47983
47984   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47985   jresult = (int)result;
47986   return jresult;
47987 }
47988
47989
47990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47991   int jresult ;
47992   int result;
47993
47994   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47995   jresult = (int)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48001   int jresult ;
48002   int result;
48003
48004   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48005   jresult = (int)result;
48006   return jresult;
48007 }
48008
48009
48010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48011   int jresult ;
48012   int result;
48013
48014   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48015   jresult = (int)result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48021   int jresult ;
48022   int result;
48023
48024   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48025   jresult = (int)result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48031   int jresult ;
48032   int result;
48033
48034   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48035   jresult = (int)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48041   void * jresult ;
48042   Dali::CameraActor::Property *result = 0 ;
48043
48044   {
48045     try {
48046       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48047     } catch (std::out_of_range& e) {
48048       {
48049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48050       };
48051     } catch (std::exception& e) {
48052       {
48053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (Dali::DaliException e) {
48056       {
48057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48058       };
48059     } catch (...) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48062       };
48063     }
48064   }
48065
48066   jresult = (void *)result;
48067   return jresult;
48068 }
48069
48070
48071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48072   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48073
48074   arg1 = (Dali::CameraActor::Property *)jarg1;
48075   {
48076     try {
48077       delete arg1;
48078     } catch (std::out_of_range& e) {
48079       {
48080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48081       };
48082     } catch (std::exception& e) {
48083       {
48084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48085       };
48086     } catch (Dali::DaliException e) {
48087       {
48088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48089       };
48090     } catch (...) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48093       };
48094     }
48095   }
48096
48097 }
48098
48099
48100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48101   void * jresult ;
48102   Dali::CameraActor *result = 0 ;
48103
48104   {
48105     try {
48106       result = (Dali::CameraActor *)new Dali::CameraActor();
48107     } catch (std::out_of_range& e) {
48108       {
48109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (std::exception& e) {
48112       {
48113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (Dali::DaliException e) {
48116       {
48117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48118       };
48119     } catch (...) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48122       };
48123     }
48124   }
48125
48126   jresult = (void *)result;
48127   return jresult;
48128 }
48129
48130
48131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48132   void * jresult ;
48133   Dali::CameraActor result;
48134
48135   {
48136     try {
48137       result = Dali::CameraActor::New();
48138     } catch (std::out_of_range& e) {
48139       {
48140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48141       };
48142     } catch (std::exception& e) {
48143       {
48144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (Dali::DaliException e) {
48147       {
48148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48149       };
48150     } catch (...) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48153       };
48154     }
48155   }
48156
48157   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48158   return jresult;
48159 }
48160
48161
48162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48163   void * jresult ;
48164   Dali::Size *arg1 = 0 ;
48165   Dali::CameraActor result;
48166
48167   arg1 = (Dali::Size *)jarg1;
48168   if (!arg1) {
48169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48170     return 0;
48171   }
48172   {
48173     try {
48174       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48175     } catch (std::out_of_range& e) {
48176       {
48177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48178       };
48179     } catch (std::exception& e) {
48180       {
48181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48182       };
48183     } catch (Dali::DaliException e) {
48184       {
48185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48186       };
48187     } catch (...) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48190       };
48191     }
48192   }
48193
48194   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48195   return jresult;
48196 }
48197
48198
48199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48200   void * jresult ;
48201   Dali::BaseHandle arg1 ;
48202   Dali::BaseHandle *argp1 ;
48203   Dali::CameraActor result;
48204
48205   argp1 = (Dali::BaseHandle *)jarg1;
48206   if (!argp1) {
48207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48208     return 0;
48209   }
48210   arg1 = *argp1;
48211   {
48212     try {
48213       result = Dali::CameraActor::DownCast(arg1);
48214     } catch (std::out_of_range& e) {
48215       {
48216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48217       };
48218     } catch (std::exception& e) {
48219       {
48220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (Dali::DaliException e) {
48223       {
48224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48225       };
48226     } catch (...) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48229       };
48230     }
48231   }
48232
48233   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48234   return jresult;
48235 }
48236
48237
48238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48239   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48240
48241   arg1 = (Dali::CameraActor *)jarg1;
48242   {
48243     try {
48244       delete arg1;
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (Dali::DaliException e) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48256       };
48257     } catch (...) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48260       };
48261     }
48262   }
48263
48264 }
48265
48266
48267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48268   void * jresult ;
48269   Dali::CameraActor *arg1 = 0 ;
48270   Dali::CameraActor *result = 0 ;
48271
48272   arg1 = (Dali::CameraActor *)jarg1;
48273   if (!arg1) {
48274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48275     return 0;
48276   }
48277   {
48278     try {
48279       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48280     } catch (std::out_of_range& e) {
48281       {
48282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48283       };
48284     } catch (std::exception& e) {
48285       {
48286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (Dali::DaliException e) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48291       };
48292     } catch (...) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48295       };
48296     }
48297   }
48298
48299   jresult = (void *)result;
48300   return jresult;
48301 }
48302
48303
48304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48305   void * jresult ;
48306   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48307   Dali::CameraActor *arg2 = 0 ;
48308   Dali::CameraActor *result = 0 ;
48309
48310   arg1 = (Dali::CameraActor *)jarg1;
48311   arg2 = (Dali::CameraActor *)jarg2;
48312   if (!arg2) {
48313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48314     return 0;
48315   }
48316   {
48317     try {
48318       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48319     } catch (std::out_of_range& e) {
48320       {
48321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48322       };
48323     } catch (std::exception& e) {
48324       {
48325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48326       };
48327     } catch (Dali::DaliException e) {
48328       {
48329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48330       };
48331     } catch (...) {
48332       {
48333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48334       };
48335     }
48336   }
48337
48338   jresult = (void *)result;
48339   return jresult;
48340 }
48341
48342
48343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48344   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48345   Dali::Camera::Type arg2 ;
48346
48347   arg1 = (Dali::CameraActor *)jarg1;
48348   arg2 = (Dali::Camera::Type)jarg2;
48349   {
48350     try {
48351       (arg1)->SetType(arg2);
48352     } catch (std::out_of_range& e) {
48353       {
48354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48355       };
48356     } catch (std::exception& e) {
48357       {
48358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (Dali::DaliException e) {
48361       {
48362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48363       };
48364     } catch (...) {
48365       {
48366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48367       };
48368     }
48369   }
48370
48371 }
48372
48373
48374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48375   int jresult ;
48376   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48377   Dali::Camera::Type result;
48378
48379   arg1 = (Dali::CameraActor *)jarg1;
48380   {
48381     try {
48382       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48383     } catch (std::out_of_range& e) {
48384       {
48385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48386       };
48387     } catch (std::exception& e) {
48388       {
48389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (Dali::DaliException e) {
48392       {
48393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48394       };
48395     } catch (...) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48398       };
48399     }
48400   }
48401
48402   jresult = (int)result;
48403   return jresult;
48404 }
48405
48406
48407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48409   Dali::Camera::ProjectionMode arg2 ;
48410
48411   arg1 = (Dali::CameraActor *)jarg1;
48412   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48413   {
48414     try {
48415       (arg1)->SetProjectionMode(arg2);
48416     } catch (std::out_of_range& e) {
48417       {
48418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48419       };
48420     } catch (std::exception& e) {
48421       {
48422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48423       };
48424     } catch (Dali::DaliException e) {
48425       {
48426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48427       };
48428     } catch (...) {
48429       {
48430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48431       };
48432     }
48433   }
48434
48435 }
48436
48437
48438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48439   int jresult ;
48440   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48441   Dali::Camera::ProjectionMode result;
48442
48443   arg1 = (Dali::CameraActor *)jarg1;
48444   {
48445     try {
48446       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48447     } catch (std::out_of_range& e) {
48448       {
48449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48450       };
48451     } catch (std::exception& e) {
48452       {
48453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (Dali::DaliException e) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48458       };
48459     } catch (...) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48462       };
48463     }
48464   }
48465
48466   jresult = (int)result;
48467   return jresult;
48468 }
48469
48470
48471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48472   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48473   float arg2 ;
48474
48475   arg1 = (Dali::CameraActor *)jarg1;
48476   arg2 = (float)jarg2;
48477   {
48478     try {
48479       (arg1)->SetFieldOfView(arg2);
48480     } catch (std::out_of_range& e) {
48481       {
48482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48483       };
48484     } catch (std::exception& e) {
48485       {
48486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (Dali::DaliException e) {
48489       {
48490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48491       };
48492     } catch (...) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48495       };
48496     }
48497   }
48498
48499 }
48500
48501
48502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48503   float jresult ;
48504   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48505   float result;
48506
48507   arg1 = (Dali::CameraActor *)jarg1;
48508   {
48509     try {
48510       result = (float)(arg1)->GetFieldOfView();
48511     } catch (std::out_of_range& e) {
48512       {
48513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48514       };
48515     } catch (std::exception& e) {
48516       {
48517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (Dali::DaliException e) {
48520       {
48521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48522       };
48523     } catch (...) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48526       };
48527     }
48528   }
48529
48530   jresult = result;
48531   return jresult;
48532 }
48533
48534
48535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48536   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48537   float arg2 ;
48538
48539   arg1 = (Dali::CameraActor *)jarg1;
48540   arg2 = (float)jarg2;
48541   {
48542     try {
48543       (arg1)->SetAspectRatio(arg2);
48544     } catch (std::out_of_range& e) {
48545       {
48546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48547       };
48548     } catch (std::exception& e) {
48549       {
48550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (Dali::DaliException e) {
48553       {
48554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48555       };
48556     } catch (...) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48559       };
48560     }
48561   }
48562
48563 }
48564
48565
48566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48567   float jresult ;
48568   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48569   float result;
48570
48571   arg1 = (Dali::CameraActor *)jarg1;
48572   {
48573     try {
48574       result = (float)(arg1)->GetAspectRatio();
48575     } catch (std::out_of_range& e) {
48576       {
48577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48578       };
48579     } catch (std::exception& e) {
48580       {
48581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48582       };
48583     } catch (Dali::DaliException e) {
48584       {
48585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48586       };
48587     } catch (...) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48590       };
48591     }
48592   }
48593
48594   jresult = result;
48595   return jresult;
48596 }
48597
48598
48599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48600   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48601   float arg2 ;
48602
48603   arg1 = (Dali::CameraActor *)jarg1;
48604   arg2 = (float)jarg2;
48605   {
48606     try {
48607       (arg1)->SetNearClippingPlane(arg2);
48608     } catch (std::out_of_range& e) {
48609       {
48610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48611       };
48612     } catch (std::exception& e) {
48613       {
48614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48615       };
48616     } catch (Dali::DaliException e) {
48617       {
48618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48619       };
48620     } catch (...) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48623       };
48624     }
48625   }
48626
48627 }
48628
48629
48630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48631   float jresult ;
48632   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48633   float result;
48634
48635   arg1 = (Dali::CameraActor *)jarg1;
48636   {
48637     try {
48638       result = (float)(arg1)->GetNearClippingPlane();
48639     } catch (std::out_of_range& e) {
48640       {
48641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48642       };
48643     } catch (std::exception& e) {
48644       {
48645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (Dali::DaliException e) {
48648       {
48649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48650       };
48651     } catch (...) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48654       };
48655     }
48656   }
48657
48658   jresult = result;
48659   return jresult;
48660 }
48661
48662
48663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48664   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48665   float arg2 ;
48666
48667   arg1 = (Dali::CameraActor *)jarg1;
48668   arg2 = (float)jarg2;
48669   {
48670     try {
48671       (arg1)->SetFarClippingPlane(arg2);
48672     } catch (std::out_of_range& e) {
48673       {
48674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48675       };
48676     } catch (std::exception& e) {
48677       {
48678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (Dali::DaliException e) {
48681       {
48682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48683       };
48684     } catch (...) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48687       };
48688     }
48689   }
48690
48691 }
48692
48693
48694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48695   float jresult ;
48696   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48697   float result;
48698
48699   arg1 = (Dali::CameraActor *)jarg1;
48700   {
48701     try {
48702       result = (float)(arg1)->GetFarClippingPlane();
48703     } catch (std::out_of_range& e) {
48704       {
48705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48706       };
48707     } catch (std::exception& e) {
48708       {
48709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48710       };
48711     } catch (Dali::DaliException e) {
48712       {
48713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48714       };
48715     } catch (...) {
48716       {
48717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48718       };
48719     }
48720   }
48721
48722   jresult = result;
48723   return jresult;
48724 }
48725
48726
48727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48728   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48729   Dali::Vector3 *arg2 = 0 ;
48730
48731   arg1 = (Dali::CameraActor *)jarg1;
48732   arg2 = (Dali::Vector3 *)jarg2;
48733   if (!arg2) {
48734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48735     return ;
48736   }
48737   {
48738     try {
48739       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48740     } catch (std::out_of_range& e) {
48741       {
48742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48743       };
48744     } catch (std::exception& e) {
48745       {
48746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48747       };
48748     } catch (Dali::DaliException e) {
48749       {
48750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48751       };
48752     } catch (...) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48755       };
48756     }
48757   }
48758
48759 }
48760
48761
48762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48763   void * jresult ;
48764   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48765   Dali::Vector3 result;
48766
48767   arg1 = (Dali::CameraActor *)jarg1;
48768   {
48769     try {
48770       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48771     } catch (std::out_of_range& e) {
48772       {
48773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48774       };
48775     } catch (std::exception& e) {
48776       {
48777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48778       };
48779     } catch (Dali::DaliException e) {
48780       {
48781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48782       };
48783     } catch (...) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48786       };
48787     }
48788   }
48789
48790   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48791   return jresult;
48792 }
48793
48794
48795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48796   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48797   bool arg2 ;
48798
48799   arg1 = (Dali::CameraActor *)jarg1;
48800   arg2 = jarg2 ? true : false;
48801   {
48802     try {
48803       (arg1)->SetInvertYAxis(arg2);
48804     } catch (std::out_of_range& e) {
48805       {
48806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48807       };
48808     } catch (std::exception& e) {
48809       {
48810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48811       };
48812     } catch (Dali::DaliException e) {
48813       {
48814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48815       };
48816     } catch (...) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48819       };
48820     }
48821   }
48822
48823 }
48824
48825
48826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48827   unsigned int jresult ;
48828   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48829   bool result;
48830
48831   arg1 = (Dali::CameraActor *)jarg1;
48832   {
48833     try {
48834       result = (bool)(arg1)->GetInvertYAxis();
48835     } catch (std::out_of_range& e) {
48836       {
48837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48838       };
48839     } catch (std::exception& e) {
48840       {
48841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (Dali::DaliException e) {
48844       {
48845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48846       };
48847     } catch (...) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48850       };
48851     }
48852   }
48853
48854   jresult = result;
48855   return jresult;
48856 }
48857
48858
48859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48860   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48861   Dali::Size *arg2 = 0 ;
48862
48863   arg1 = (Dali::CameraActor *)jarg1;
48864   arg2 = (Dali::Size *)jarg2;
48865   if (!arg2) {
48866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48867     return ;
48868   }
48869   {
48870     try {
48871       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48872     } catch (std::out_of_range& e) {
48873       {
48874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48875       };
48876     } catch (std::exception& e) {
48877       {
48878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (Dali::DaliException e) {
48881       {
48882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48887       };
48888     }
48889   }
48890
48891 }
48892
48893
48894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48895   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48896   Dali::Size *arg2 = 0 ;
48897
48898   arg1 = (Dali::CameraActor *)jarg1;
48899   arg2 = (Dali::Size *)jarg2;
48900   if (!arg2) {
48901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48902     return ;
48903   }
48904   {
48905     try {
48906       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48907     } catch (std::out_of_range& e) {
48908       {
48909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48910       };
48911     } catch (std::exception& e) {
48912       {
48913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (Dali::DaliException e) {
48916       {
48917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48918       };
48919     } catch (...) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48922       };
48923     }
48924   }
48925
48926 }
48927
48928
48929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48930   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48931   float arg2 ;
48932   float arg3 ;
48933   float arg4 ;
48934   float arg5 ;
48935   float arg6 ;
48936   float arg7 ;
48937
48938   arg1 = (Dali::CameraActor *)jarg1;
48939   arg2 = (float)jarg2;
48940   arg3 = (float)jarg3;
48941   arg4 = (float)jarg4;
48942   arg5 = (float)jarg5;
48943   arg6 = (float)jarg6;
48944   arg7 = (float)jarg7;
48945   {
48946     try {
48947       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48948     } catch (std::out_of_range& e) {
48949       {
48950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48951       };
48952     } catch (std::exception& e) {
48953       {
48954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48955       };
48956     } catch (Dali::DaliException e) {
48957       {
48958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48959       };
48960     } catch (...) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48963       };
48964     }
48965   }
48966
48967 }
48968
48969
48970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48971   void * jresult ;
48972   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48973
48974   {
48975     try {
48976       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48977     } catch (std::out_of_range& e) {
48978       {
48979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48980       };
48981     } catch (std::exception& e) {
48982       {
48983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (Dali::DaliException e) {
48986       {
48987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48988       };
48989     } catch (...) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48992       };
48993     }
48994   }
48995
48996   jresult = (void *)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49002   void * jresult ;
49003   std::string arg1 ;
49004   Dali::Property::Value arg2 ;
49005   Dali::Property::Value *argp2 ;
49006   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49007
49008   if (!jarg1) {
49009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49010     return 0;
49011   }
49012   (&arg1)->assign(jarg1);
49013   argp2 = (Dali::Property::Value *)jarg2;
49014   if (!argp2) {
49015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49016     return 0;
49017   }
49018   arg2 = *argp2;
49019   {
49020     try {
49021       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49022     } catch (std::out_of_range& e) {
49023       {
49024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49025       };
49026     } catch (std::exception& e) {
49027       {
49028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49029       };
49030     } catch (Dali::DaliException e) {
49031       {
49032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49033       };
49034     } catch (...) {
49035       {
49036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49037       };
49038     }
49039   }
49040
49041   jresult = (void *)result;
49042   return jresult;
49043 }
49044
49045
49046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49047   void * jresult ;
49048   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49049   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49050
49051   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49052   if (!arg1) {
49053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49054     return 0;
49055   }
49056   {
49057     try {
49058       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);
49059     } catch (std::out_of_range& e) {
49060       {
49061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49062       };
49063     } catch (std::exception& e) {
49064       {
49065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (Dali::DaliException e) {
49068       {
49069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49070       };
49071     } catch (...) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49074       };
49075     }
49076   }
49077
49078   jresult = (void *)result;
49079   return jresult;
49080 }
49081
49082
49083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49084   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49085   std::string *arg2 = 0 ;
49086
49087   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49088   if (!jarg2) {
49089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49090     return ;
49091   }
49092   std::string arg2_str(jarg2);
49093   arg2 = &arg2_str;
49094   if (arg1) (arg1)->first = *arg2;
49095
49096   //argout typemap for const std::string&
49097
49098 }
49099
49100
49101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49102   char * jresult ;
49103   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49104   std::string *result = 0 ;
49105
49106   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49107   result = (std::string *) & ((arg1)->first);
49108   jresult = SWIG_csharp_string_callback(result->c_str());
49109   return jresult;
49110 }
49111
49112
49113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49114   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49115   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49116
49117   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49118   arg2 = (Dali::Property::Value *)jarg2;
49119   if (arg1) (arg1)->second = *arg2;
49120 }
49121
49122
49123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49124   void * jresult ;
49125   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49126   Dali::Property::Value *result = 0 ;
49127
49128   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49129   result = (Dali::Property::Value *)& ((arg1)->second);
49130   jresult = (void *)result;
49131   return jresult;
49132 }
49133
49134
49135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49136   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49137
49138   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49139   {
49140     try {
49141       delete arg1;
49142     } catch (std::out_of_range& e) {
49143       {
49144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49145       };
49146     } catch (std::exception& e) {
49147       {
49148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (Dali::DaliException e) {
49151       {
49152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49153       };
49154     } catch (...) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49157       };
49158     }
49159   }
49160
49161 }
49162
49163
49164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49165   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49166
49167   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49168   {
49169     try {
49170       (arg1)->clear();
49171     } catch (std::out_of_range& e) {
49172       {
49173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49174       };
49175     } catch (std::exception& e) {
49176       {
49177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49178       };
49179     } catch (Dali::DaliException e) {
49180       {
49181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49182       };
49183     } catch (...) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49186       };
49187     }
49188   }
49189
49190 }
49191
49192
49193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49195   Dali::TouchPoint *arg2 = 0 ;
49196
49197   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49198   arg2 = (Dali::TouchPoint *)jarg2;
49199   if (!arg2) {
49200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49201     return ;
49202   }
49203   {
49204     try {
49205       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49206     } catch (std::out_of_range& e) {
49207       {
49208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49209       };
49210     } catch (std::exception& e) {
49211       {
49212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (Dali::DaliException e) {
49215       {
49216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49217       };
49218     } catch (...) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49221       };
49222     }
49223   }
49224
49225 }
49226
49227
49228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49229   unsigned long jresult ;
49230   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49231   std::vector< Dali::TouchPoint >::size_type result;
49232
49233   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49234   {
49235     try {
49236       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49237     } catch (std::out_of_range& e) {
49238       {
49239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49240       };
49241     } catch (std::exception& e) {
49242       {
49243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (Dali::DaliException e) {
49246       {
49247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49248       };
49249     } catch (...) {
49250       {
49251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49252       };
49253     }
49254   }
49255
49256   jresult = (unsigned long)result;
49257   return jresult;
49258 }
49259
49260
49261 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49262   unsigned long jresult ;
49263   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49264   std::vector< Dali::TouchPoint >::size_type result;
49265
49266   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49267   {
49268     try {
49269       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49270     } catch (std::out_of_range& e) {
49271       {
49272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49273       };
49274     } catch (std::exception& e) {
49275       {
49276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (Dali::DaliException e) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49281       };
49282     } catch (...) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49285       };
49286     }
49287   }
49288
49289   jresult = (unsigned long)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49295   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49296   std::vector< Dali::TouchPoint >::size_type arg2 ;
49297
49298   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49299   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49300   {
49301     try {
49302       (arg1)->reserve(arg2);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (Dali::DaliException e) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49314       };
49315     } catch (...) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49318       };
49319     }
49320   }
49321
49322 }
49323
49324
49325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49326   void * jresult ;
49327   std::vector< Dali::TouchPoint > *result = 0 ;
49328
49329   {
49330     try {
49331       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49332     } catch (std::out_of_range& e) {
49333       {
49334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49335       };
49336     } catch (std::exception& e) {
49337       {
49338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (Dali::DaliException e) {
49341       {
49342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49343       };
49344     } catch (...) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49347       };
49348     }
49349   }
49350
49351   jresult = (void *)result;
49352   return jresult;
49353 }
49354
49355
49356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49357   void * jresult ;
49358   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49359   std::vector< Dali::TouchPoint > *result = 0 ;
49360
49361   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49362   if (!arg1) {
49363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49364     return 0;
49365   }
49366   {
49367     try {
49368       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49369     } catch (std::out_of_range& e) {
49370       {
49371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49372       };
49373     } catch (std::exception& e) {
49374       {
49375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49376       };
49377     } catch (Dali::DaliException e) {
49378       {
49379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49380       };
49381     } catch (...) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49384       };
49385     }
49386   }
49387
49388   jresult = (void *)result;
49389   return jresult;
49390 }
49391
49392
49393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49394   void * jresult ;
49395   int arg1 ;
49396   std::vector< Dali::TouchPoint > *result = 0 ;
49397
49398   arg1 = (int)jarg1;
49399   {
49400     try {
49401       try {
49402         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49403       }
49404       catch(std::out_of_range &_e) {
49405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49406         return 0;
49407       }
49408
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49416       };
49417     } catch (Dali::DaliException e) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49424       };
49425     }
49426   }
49427
49428   jresult = (void *)result;
49429   return jresult;
49430 }
49431
49432
49433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49434   void * jresult ;
49435   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49436   int arg2 ;
49437   SwigValueWrapper< Dali::TouchPoint > result;
49438
49439   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49440   arg2 = (int)jarg2;
49441   {
49442     try {
49443       try {
49444         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49445       }
49446       catch(std::out_of_range &_e) {
49447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49448         return 0;
49449       }
49450
49451     } catch (std::out_of_range& e) {
49452       {
49453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49454       };
49455     } catch (std::exception& e) {
49456       {
49457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49458       };
49459     } catch (Dali::DaliException e) {
49460       {
49461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49462       };
49463     } catch (...) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49466       };
49467     }
49468   }
49469
49470   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49471   return jresult;
49472 }
49473
49474
49475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49476   void * jresult ;
49477   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49478   int arg2 ;
49479   Dali::TouchPoint *result = 0 ;
49480
49481   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49482   arg2 = (int)jarg2;
49483   {
49484     try {
49485       try {
49486         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49487       }
49488       catch(std::out_of_range &_e) {
49489         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49490         return 0;
49491       }
49492
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (Dali::DaliException e) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49504       };
49505     } catch (...) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49508       };
49509     }
49510   }
49511
49512   jresult = (void *)result;
49513   return jresult;
49514 }
49515
49516
49517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49518   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49519   int arg2 ;
49520   Dali::TouchPoint *arg3 = 0 ;
49521
49522   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49523   arg2 = (int)jarg2;
49524   arg3 = (Dali::TouchPoint *)jarg3;
49525   if (!arg3) {
49526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49527     return ;
49528   }
49529   {
49530     try {
49531       try {
49532         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49533       }
49534       catch(std::out_of_range &_e) {
49535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49536         return ;
49537       }
49538
49539     } catch (std::out_of_range& e) {
49540       {
49541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49542       };
49543     } catch (std::exception& e) {
49544       {
49545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (Dali::DaliException e) {
49548       {
49549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49554       };
49555     }
49556   }
49557
49558 }
49559
49560
49561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49562   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49563   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49564
49565   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49566   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49567   if (!arg2) {
49568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49569     return ;
49570   }
49571   {
49572     try {
49573       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49574     } catch (std::out_of_range& e) {
49575       {
49576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49577       };
49578     } catch (std::exception& e) {
49579       {
49580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (Dali::DaliException e) {
49583       {
49584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49585       };
49586     } catch (...) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49589       };
49590     }
49591   }
49592
49593 }
49594
49595
49596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49597   void * jresult ;
49598   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49599   int arg2 ;
49600   int arg3 ;
49601   std::vector< Dali::TouchPoint > *result = 0 ;
49602
49603   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49604   arg2 = (int)jarg2;
49605   arg3 = (int)jarg3;
49606   {
49607     try {
49608       try {
49609         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49610       }
49611       catch(std::out_of_range &_e) {
49612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49613         return 0;
49614       }
49615       catch(std::invalid_argument &_e) {
49616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49617         return 0;
49618       }
49619
49620     } catch (std::out_of_range& e) {
49621       {
49622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49623       };
49624     } catch (std::exception& e) {
49625       {
49626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (Dali::DaliException e) {
49629       {
49630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49635       };
49636     }
49637   }
49638
49639   jresult = (void *)result;
49640   return jresult;
49641 }
49642
49643
49644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49646   int arg2 ;
49647   Dali::TouchPoint *arg3 = 0 ;
49648
49649   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49650   arg2 = (int)jarg2;
49651   arg3 = (Dali::TouchPoint *)jarg3;
49652   if (!arg3) {
49653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49654     return ;
49655   }
49656   {
49657     try {
49658       try {
49659         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49660       }
49661       catch(std::out_of_range &_e) {
49662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49663         return ;
49664       }
49665
49666     } catch (std::out_of_range& e) {
49667       {
49668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49669       };
49670     } catch (std::exception& e) {
49671       {
49672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (Dali::DaliException e) {
49675       {
49676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49677       };
49678     } catch (...) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49681       };
49682     }
49683   }
49684
49685 }
49686
49687
49688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49689   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49690   int arg2 ;
49691   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49692
49693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49694   arg2 = (int)jarg2;
49695   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49696   if (!arg3) {
49697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49698     return ;
49699   }
49700   {
49701     try {
49702       try {
49703         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49704       }
49705       catch(std::out_of_range &_e) {
49706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49707         return ;
49708       }
49709
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (Dali::DaliException e) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49721       };
49722     } catch (...) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49725       };
49726     }
49727   }
49728
49729 }
49730
49731
49732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49733   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49734   int arg2 ;
49735
49736   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49737   arg2 = (int)jarg2;
49738   {
49739     try {
49740       try {
49741         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49742       }
49743       catch(std::out_of_range &_e) {
49744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49745         return ;
49746       }
49747
49748     } catch (std::out_of_range& e) {
49749       {
49750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49751       };
49752     } catch (std::exception& e) {
49753       {
49754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (Dali::DaliException e) {
49757       {
49758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49759       };
49760     } catch (...) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49763       };
49764     }
49765   }
49766
49767 }
49768
49769
49770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49771   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49772   int arg2 ;
49773   int arg3 ;
49774
49775   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49776   arg2 = (int)jarg2;
49777   arg3 = (int)jarg3;
49778   {
49779     try {
49780       try {
49781         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49782       }
49783       catch(std::out_of_range &_e) {
49784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49785         return ;
49786       }
49787       catch(std::invalid_argument &_e) {
49788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49789         return ;
49790       }
49791
49792     } catch (std::out_of_range& e) {
49793       {
49794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49795       };
49796     } catch (std::exception& e) {
49797       {
49798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49799       };
49800     } catch (Dali::DaliException e) {
49801       {
49802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49803       };
49804     } catch (...) {
49805       {
49806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49807       };
49808     }
49809   }
49810
49811 }
49812
49813
49814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49815   void * jresult ;
49816   Dali::TouchPoint *arg1 = 0 ;
49817   int arg2 ;
49818   std::vector< Dali::TouchPoint > *result = 0 ;
49819
49820   arg1 = (Dali::TouchPoint *)jarg1;
49821   if (!arg1) {
49822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49823     return 0;
49824   }
49825   arg2 = (int)jarg2;
49826   {
49827     try {
49828       try {
49829         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49830       }
49831       catch(std::out_of_range &_e) {
49832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49833         return 0;
49834       }
49835
49836     } catch (std::out_of_range& e) {
49837       {
49838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49839       };
49840     } catch (std::exception& e) {
49841       {
49842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (Dali::DaliException e) {
49845       {
49846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49847       };
49848     } catch (...) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49851       };
49852     }
49853   }
49854
49855   jresult = (void *)result;
49856   return jresult;
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49861   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49862
49863   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49864   {
49865     try {
49866       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49867     } catch (std::out_of_range& e) {
49868       {
49869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49870       };
49871     } catch (std::exception& e) {
49872       {
49873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (Dali::DaliException e) {
49876       {
49877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49878       };
49879     } catch (...) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49882       };
49883     }
49884   }
49885
49886 }
49887
49888
49889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49890   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49891   int arg2 ;
49892   int arg3 ;
49893
49894   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49895   arg2 = (int)jarg2;
49896   arg3 = (int)jarg3;
49897   {
49898     try {
49899       try {
49900         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49901       }
49902       catch(std::out_of_range &_e) {
49903         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49904         return ;
49905       }
49906       catch(std::invalid_argument &_e) {
49907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49908         return ;
49909       }
49910
49911     } catch (std::out_of_range& e) {
49912       {
49913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49914       };
49915     } catch (std::exception& e) {
49916       {
49917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (Dali::DaliException e) {
49920       {
49921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49922       };
49923     } catch (...) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49926       };
49927     }
49928   }
49929
49930 }
49931
49932
49933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49934   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49935   int arg2 ;
49936   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49937
49938   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49939   arg2 = (int)jarg2;
49940   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49941   if (!arg3) {
49942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49943     return ;
49944   }
49945   {
49946     try {
49947       try {
49948         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49949       }
49950       catch(std::out_of_range &_e) {
49951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49952         return ;
49953       }
49954
49955     } catch (std::out_of_range& e) {
49956       {
49957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49958       };
49959     } catch (std::exception& e) {
49960       {
49961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (Dali::DaliException e) {
49964       {
49965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49966       };
49967     } catch (...) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49970       };
49971     }
49972   }
49973
49974 }
49975
49976
49977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49978   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49979
49980   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49981   {
49982     try {
49983       delete arg1;
49984     } catch (std::out_of_range& e) {
49985       {
49986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49987       };
49988     } catch (std::exception& e) {
49989       {
49990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49991       };
49992     } catch (Dali::DaliException e) {
49993       {
49994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49995       };
49996     } catch (...) {
49997       {
49998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49999       };
50000     }
50001   }
50002
50003 }
50004
50005
50006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50007   void * jresult ;
50008   Dali::Rect< int > *result = 0 ;
50009
50010   {
50011     try {
50012       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50013     } catch (std::out_of_range& e) {
50014       {
50015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50016       };
50017     } catch (std::exception& e) {
50018       {
50019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50020       };
50021     } catch (Dali::DaliException e) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50024       };
50025     } catch (...) {
50026       {
50027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50028       };
50029     }
50030   }
50031
50032   jresult = (void *)result;
50033   return jresult;
50034 }
50035
50036
50037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50038   void * jresult ;
50039   int arg1 ;
50040   int arg2 ;
50041   int arg3 ;
50042   int arg4 ;
50043   Dali::Rect< int > *result = 0 ;
50044
50045   arg1 = (int)jarg1;
50046   arg2 = (int)jarg2;
50047   arg3 = (int)jarg3;
50048   arg4 = (int)jarg4;
50049   {
50050     try {
50051       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50052     } catch (std::out_of_range& e) {
50053       {
50054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50055       };
50056     } catch (std::exception& e) {
50057       {
50058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50059       };
50060     } catch (Dali::DaliException e) {
50061       {
50062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50063       };
50064     } catch (...) {
50065       {
50066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50067       };
50068     }
50069   }
50070
50071   jresult = (void *)result;
50072   return jresult;
50073 }
50074
50075
50076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50077   void * jresult ;
50078   Dali::Rect< int > *arg1 = 0 ;
50079   Dali::Rect< int > *result = 0 ;
50080
50081   arg1 = (Dali::Rect< int > *)jarg1;
50082   if (!arg1) {
50083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50084     return 0;
50085   }
50086   {
50087     try {
50088       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50089     } catch (std::out_of_range& e) {
50090       {
50091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50092       };
50093     } catch (std::exception& e) {
50094       {
50095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50096       };
50097     } catch (Dali::DaliException e) {
50098       {
50099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50100       };
50101     } catch (...) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50104       };
50105     }
50106   }
50107
50108   jresult = (void *)result;
50109   return jresult;
50110 }
50111
50112
50113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50114   void * jresult ;
50115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50116   Dali::Rect< int > *arg2 = 0 ;
50117   Dali::Rect< int > *result = 0 ;
50118
50119   arg1 = (Dali::Rect< int > *)jarg1;
50120   arg2 = (Dali::Rect< int > *)jarg2;
50121   if (!arg2) {
50122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50123     return 0;
50124   }
50125   {
50126     try {
50127       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50128     } catch (std::out_of_range& e) {
50129       {
50130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50131       };
50132     } catch (std::exception& e) {
50133       {
50134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (Dali::DaliException e) {
50137       {
50138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50139       };
50140     } catch (...) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50143       };
50144     }
50145   }
50146
50147   jresult = (void *)result;
50148   return jresult;
50149 }
50150
50151
50152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50153   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50154   int arg2 ;
50155   int arg3 ;
50156   int arg4 ;
50157   int arg5 ;
50158
50159   arg1 = (Dali::Rect< int > *)jarg1;
50160   arg2 = (int)jarg2;
50161   arg3 = (int)jarg3;
50162   arg4 = (int)jarg4;
50163   arg5 = (int)jarg5;
50164   {
50165     try {
50166       (arg1)->Set(arg2,arg3,arg4,arg5);
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50174       };
50175     } catch (Dali::DaliException e) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50178       };
50179     } catch (...) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50182       };
50183     }
50184   }
50185
50186 }
50187
50188
50189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50190   unsigned int jresult ;
50191   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50192   bool result;
50193
50194   arg1 = (Dali::Rect< int > *)jarg1;
50195   {
50196     try {
50197       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50198     } catch (std::out_of_range& e) {
50199       {
50200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50201       };
50202     } catch (std::exception& e) {
50203       {
50204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50205       };
50206     } catch (Dali::DaliException e) {
50207       {
50208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50209       };
50210     } catch (...) {
50211       {
50212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50213       };
50214     }
50215   }
50216
50217   jresult = result;
50218   return jresult;
50219 }
50220
50221
50222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50223   int jresult ;
50224   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50225   int result;
50226
50227   arg1 = (Dali::Rect< int > *)jarg1;
50228   {
50229     try {
50230       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50231     } catch (std::out_of_range& e) {
50232       {
50233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50234       };
50235     } catch (std::exception& e) {
50236       {
50237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50238       };
50239     } catch (Dali::DaliException e) {
50240       {
50241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50242       };
50243     } catch (...) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50246       };
50247     }
50248   }
50249
50250   jresult = result;
50251   return jresult;
50252 }
50253
50254
50255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50256   int jresult ;
50257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50258   int result;
50259
50260   arg1 = (Dali::Rect< int > *)jarg1;
50261   {
50262     try {
50263       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50264     } catch (std::out_of_range& e) {
50265       {
50266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50267       };
50268     } catch (std::exception& e) {
50269       {
50270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (Dali::DaliException e) {
50273       {
50274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50275       };
50276     } catch (...) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50279       };
50280     }
50281   }
50282
50283   jresult = result;
50284   return jresult;
50285 }
50286
50287
50288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50289   int jresult ;
50290   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50291   int result;
50292
50293   arg1 = (Dali::Rect< int > *)jarg1;
50294   {
50295     try {
50296       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50297     } catch (std::out_of_range& e) {
50298       {
50299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50300       };
50301     } catch (std::exception& e) {
50302       {
50303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50304       };
50305     } catch (Dali::DaliException e) {
50306       {
50307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50312       };
50313     }
50314   }
50315
50316   jresult = result;
50317   return jresult;
50318 }
50319
50320
50321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50322   int jresult ;
50323   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50324   int result;
50325
50326   arg1 = (Dali::Rect< int > *)jarg1;
50327   {
50328     try {
50329       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50330     } catch (std::out_of_range& e) {
50331       {
50332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50333       };
50334     } catch (std::exception& e) {
50335       {
50336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50337       };
50338     } catch (Dali::DaliException e) {
50339       {
50340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50341       };
50342     } catch (...) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50345       };
50346     }
50347   }
50348
50349   jresult = result;
50350   return jresult;
50351 }
50352
50353
50354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50355   int jresult ;
50356   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50357   int result;
50358
50359   arg1 = (Dali::Rect< int > *)jarg1;
50360   {
50361     try {
50362       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50363     } catch (std::out_of_range& e) {
50364       {
50365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50366       };
50367     } catch (std::exception& e) {
50368       {
50369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (Dali::DaliException e) {
50372       {
50373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381
50382   jresult = result;
50383   return jresult;
50384 }
50385
50386
50387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50388   unsigned int jresult ;
50389   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50390   Dali::Rect< int > *arg2 = 0 ;
50391   bool result;
50392
50393   arg1 = (Dali::Rect< int > *)jarg1;
50394   arg2 = (Dali::Rect< int > *)jarg2;
50395   if (!arg2) {
50396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50397     return 0;
50398   }
50399   {
50400     try {
50401       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50402     } catch (std::out_of_range& e) {
50403       {
50404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50405       };
50406     } catch (std::exception& e) {
50407       {
50408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50409       };
50410     } catch (Dali::DaliException e) {
50411       {
50412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50413       };
50414     } catch (...) {
50415       {
50416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50417       };
50418     }
50419   }
50420
50421   jresult = result;
50422   return jresult;
50423 }
50424
50425
50426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50427   unsigned int jresult ;
50428   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50429   Dali::Rect< int > *arg2 = 0 ;
50430   bool result;
50431
50432   arg1 = (Dali::Rect< int > *)jarg1;
50433   arg2 = (Dali::Rect< int > *)jarg2;
50434   if (!arg2) {
50435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50436     return 0;
50437   }
50438   {
50439     try {
50440       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50441     } catch (std::out_of_range& e) {
50442       {
50443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50444       };
50445     } catch (std::exception& e) {
50446       {
50447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50448       };
50449     } catch (Dali::DaliException e) {
50450       {
50451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50452       };
50453     } catch (...) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50456       };
50457     }
50458   }
50459
50460   jresult = result;
50461   return jresult;
50462 }
50463
50464
50465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50466   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50467   int arg2 ;
50468
50469   arg1 = (Dali::Rect< int > *)jarg1;
50470   arg2 = (int)jarg2;
50471   if (arg1) (arg1)->x = arg2;
50472 }
50473
50474
50475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50476   int jresult ;
50477   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50478   int result;
50479
50480   arg1 = (Dali::Rect< int > *)jarg1;
50481   result = (int) ((arg1)->x);
50482   jresult = result;
50483   return jresult;
50484 }
50485
50486
50487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50488   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50489   int arg2 ;
50490
50491   arg1 = (Dali::Rect< int > *)jarg1;
50492   arg2 = (int)jarg2;
50493   if (arg1) (arg1)->left = arg2;
50494 }
50495
50496
50497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50498   int jresult ;
50499   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50500   int result;
50501
50502   arg1 = (Dali::Rect< int > *)jarg1;
50503   result = (int) ((arg1)->left);
50504   jresult = result;
50505   return jresult;
50506 }
50507
50508
50509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50510   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50511   int arg2 ;
50512
50513   arg1 = (Dali::Rect< int > *)jarg1;
50514   arg2 = (int)jarg2;
50515   if (arg1) (arg1)->y = arg2;
50516 }
50517
50518
50519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50520   int jresult ;
50521   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50522   int result;
50523
50524   arg1 = (Dali::Rect< int > *)jarg1;
50525   result = (int) ((arg1)->y);
50526   jresult = result;
50527   return jresult;
50528 }
50529
50530
50531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50532   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50533   int arg2 ;
50534
50535   arg1 = (Dali::Rect< int > *)jarg1;
50536   arg2 = (int)jarg2;
50537   if (arg1) (arg1)->right = arg2;
50538 }
50539
50540
50541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50542   int jresult ;
50543   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50544   int result;
50545
50546   arg1 = (Dali::Rect< int > *)jarg1;
50547   result = (int) ((arg1)->right);
50548   jresult = result;
50549   return jresult;
50550 }
50551
50552
50553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50554   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50555   int arg2 ;
50556
50557   arg1 = (Dali::Rect< int > *)jarg1;
50558   arg2 = (int)jarg2;
50559   if (arg1) (arg1)->width = arg2;
50560 }
50561
50562
50563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50564   int jresult ;
50565   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50566   int result;
50567
50568   arg1 = (Dali::Rect< int > *)jarg1;
50569   result = (int) ((arg1)->width);
50570   jresult = result;
50571   return jresult;
50572 }
50573
50574
50575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50576   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50577   int arg2 ;
50578
50579   arg1 = (Dali::Rect< int > *)jarg1;
50580   arg2 = (int)jarg2;
50581   if (arg1) (arg1)->bottom = arg2;
50582 }
50583
50584
50585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50586   int jresult ;
50587   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50588   int result;
50589
50590   arg1 = (Dali::Rect< int > *)jarg1;
50591   result = (int) ((arg1)->bottom);
50592   jresult = result;
50593   return jresult;
50594 }
50595
50596
50597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50598   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50599   int arg2 ;
50600
50601   arg1 = (Dali::Rect< int > *)jarg1;
50602   arg2 = (int)jarg2;
50603   if (arg1) (arg1)->height = arg2;
50604 }
50605
50606
50607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50608   int jresult ;
50609   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50610   int result;
50611
50612   arg1 = (Dali::Rect< int > *)jarg1;
50613   result = (int) ((arg1)->height);
50614   jresult = result;
50615   return jresult;
50616 }
50617
50618
50619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50620   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50621   int arg2 ;
50622
50623   arg1 = (Dali::Rect< int > *)jarg1;
50624   arg2 = (int)jarg2;
50625   if (arg1) (arg1)->top = arg2;
50626 }
50627
50628
50629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50630   int jresult ;
50631   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50632   int result;
50633
50634   arg1 = (Dali::Rect< int > *)jarg1;
50635   result = (int) ((arg1)->top);
50636   jresult = result;
50637   return jresult;
50638 }
50639
50640
50641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50642   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50643
50644   arg1 = (Dali::Rect< int > *)jarg1;
50645   {
50646     try {
50647       delete arg1;
50648     } catch (std::out_of_range& e) {
50649       {
50650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50651       };
50652     } catch (std::exception& e) {
50653       {
50654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50655       };
50656     } catch (Dali::DaliException e) {
50657       {
50658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50659       };
50660     } catch (...) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50663       };
50664     }
50665   }
50666
50667 }
50668
50669
50670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50671   void * jresult ;
50672   Dali::Rect< float > *result = 0 ;
50673
50674   {
50675     try {
50676       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50677     } catch (std::out_of_range& e) {
50678       {
50679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50680       };
50681     } catch (std::exception& e) {
50682       {
50683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50684       };
50685     } catch (Dali::DaliException e) {
50686       {
50687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50688       };
50689     } catch (...) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50692       };
50693     }
50694   }
50695
50696   jresult = (void *)result;
50697   return jresult;
50698 }
50699
50700
50701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50702   void * jresult ;
50703   float arg1 ;
50704   float arg2 ;
50705   float arg3 ;
50706   float arg4 ;
50707   Dali::Rect< float > *result = 0 ;
50708
50709   arg1 = (float)jarg1;
50710   arg2 = (float)jarg2;
50711   arg3 = (float)jarg4;
50712   arg4 = (float)jarg3;
50713   {
50714     try {
50715       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50716     } catch (std::out_of_range& e) {
50717       {
50718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50719       };
50720     } catch (std::exception& e) {
50721       {
50722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50723       };
50724     } catch (Dali::DaliException e) {
50725       {
50726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50727       };
50728     } catch (...) {
50729       {
50730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50731       };
50732     }
50733   }
50734
50735   jresult = (void *)result;
50736   return jresult;
50737 }
50738
50739
50740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50741   void * jresult ;
50742   Dali::Rect< float > *arg1 = 0 ;
50743   Dali::Rect< float > *result = 0 ;
50744
50745   arg1 = (Dali::Rect< float > *)jarg1;
50746   if (!arg1) {
50747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50748     return 0;
50749   }
50750   {
50751     try {
50752       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50753     } catch (std::out_of_range& e) {
50754       {
50755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50756       };
50757     } catch (std::exception& e) {
50758       {
50759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50760       };
50761     } catch (Dali::DaliException e) {
50762       {
50763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50764       };
50765     } catch (...) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50768       };
50769     }
50770   }
50771
50772   jresult = (void *)result;
50773   return jresult;
50774 }
50775
50776
50777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50778   void * jresult ;
50779   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50780   Dali::Rect< float > *arg2 = 0 ;
50781   Dali::Rect< float > *result = 0 ;
50782
50783   arg1 = (Dali::Rect< float > *)jarg1;
50784   arg2 = (Dali::Rect< float > *)jarg2;
50785   if (!arg2) {
50786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50787     return 0;
50788   }
50789   {
50790     try {
50791       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50792     } catch (std::out_of_range& e) {
50793       {
50794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50795       };
50796     } catch (std::exception& e) {
50797       {
50798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50799       };
50800     } catch (Dali::DaliException e) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50803       };
50804     } catch (...) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50807       };
50808     }
50809   }
50810
50811   jresult = (void *)result;
50812   return jresult;
50813 }
50814
50815
50816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50817   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50818   float arg2 ;
50819   float arg3 ;
50820   float arg4 ;
50821   float arg5 ;
50822
50823   arg1 = (Dali::Rect< float > *)jarg1;
50824   arg2 = (float)jarg2;
50825   arg3 = (float)jarg3;
50826   arg4 = (float)jarg5;
50827   arg5 = (float)jarg4;
50828   {
50829     try {
50830       (arg1)->Set(arg2,arg3,arg4,arg5);
50831     } catch (std::out_of_range& e) {
50832       {
50833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50834       };
50835     } catch (std::exception& e) {
50836       {
50837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50838       };
50839     } catch (Dali::DaliException e) {
50840       {
50841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50842       };
50843     } catch (...) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50846       };
50847     }
50848   }
50849
50850 }
50851
50852
50853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50854   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50855   float arg2 ;
50856
50857   arg1 = (Dali::Rect< float > *)jarg1;
50858   arg2 = (float)jarg2;
50859   if (arg1) (arg1)->left = arg2;
50860 }
50861
50862
50863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50864   float jresult ;
50865   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50866   float result;
50867
50868   arg1 = (Dali::Rect< float > *)jarg1;
50869   result = (float) ((arg1)->left);
50870   jresult = result;
50871   return jresult;
50872 }
50873
50874
50875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50876   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50877   float arg2 ;
50878
50879   arg1 = (Dali::Rect< float > *)jarg1;
50880   arg2 = (float)jarg2;
50881   if (arg1) (arg1)->left = arg2;
50882 }
50883
50884
50885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50886   float jresult ;
50887   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50888   float result;
50889
50890   arg1 = (Dali::Rect< float > *)jarg1;
50891   result = (float) ((arg1)->left);
50892   jresult = result;
50893   return jresult;
50894 }
50895
50896
50897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50898   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50899   float arg2 ;
50900
50901   arg1 = (Dali::Rect< float > *)jarg1;
50902   arg2 = (float)jarg2;
50903   if (arg1) (arg1)->right = arg2;
50904 }
50905
50906
50907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50908   float jresult ;
50909   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50910   float result;
50911
50912   arg1 = (Dali::Rect< float > *)jarg1;
50913   result = (float) ((arg1)->right);
50914   jresult = result;
50915   return jresult;
50916 }
50917
50918
50919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50920   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50921   float arg2 ;
50922
50923   arg1 = (Dali::Rect< float > *)jarg1;
50924   arg2 = (float)jarg2;
50925   if (arg1) (arg1)->right = arg2;
50926 }
50927
50928
50929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50930   float jresult ;
50931   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50932   float result;
50933
50934   arg1 = (Dali::Rect< float > *)jarg1;
50935   result = (float) ((arg1)->right);
50936   jresult = result;
50937   return jresult;
50938 }
50939
50940
50941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50942   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50943   float arg2 ;
50944
50945   arg1 = (Dali::Rect< float > *)jarg1;
50946   arg2 = (float)jarg2;
50947   if (arg1) (arg1)->bottom = arg2;
50948 }
50949
50950
50951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50952   float jresult ;
50953   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50954   float result;
50955
50956   arg1 = (Dali::Rect< float > *)jarg1;
50957   result = (float) ((arg1)->bottom);
50958   jresult = result;
50959   return jresult;
50960 }
50961
50962
50963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50964   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50965   float arg2 ;
50966
50967   arg1 = (Dali::Rect< float > *)jarg1;
50968   arg2 = (float)jarg2;
50969   if (arg1) (arg1)->top = arg2;
50970 }
50971
50972
50973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50974   float jresult ;
50975   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50976   float result;
50977
50978   arg1 = (Dali::Rect< float > *)jarg1;
50979   result = (float) ((arg1)->top);
50980   jresult = result;
50981   return jresult;
50982 }
50983
50984
50985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50986   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50987
50988   arg1 = (Dali::Rect< float > *)jarg1;
50989   {
50990     try {
50991       delete arg1;
50992     } catch (std::out_of_range& e) {
50993       {
50994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50995       };
50996     } catch (std::exception& e) {
50997       {
50998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (Dali::DaliException e) {
51001       {
51002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51007       };
51008     }
51009   }
51010
51011 }
51012
51013
51014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51015   int jresult ;
51016   int result;
51017
51018   result = (int)Dali::Vector< int >::BaseType;
51019   jresult = (int)result;
51020   return jresult;
51021 }
51022
51023
51024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51025   void * jresult ;
51026   Dali::Vector< int > *result = 0 ;
51027
51028   {
51029     try {
51030       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51031     } catch (std::out_of_range& e) {
51032       {
51033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51034       };
51035     } catch (std::exception& e) {
51036       {
51037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (Dali::DaliException e) {
51040       {
51041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51042       };
51043     } catch (...) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51046       };
51047     }
51048   }
51049
51050   jresult = (void *)result;
51051   return jresult;
51052 }
51053
51054
51055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51056   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51057
51058   arg1 = (Dali::Vector< int > *)jarg1;
51059   {
51060     try {
51061       delete arg1;
51062     } catch (std::out_of_range& e) {
51063       {
51064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51065       };
51066     } catch (std::exception& e) {
51067       {
51068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51069       };
51070     } catch (Dali::DaliException e) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51073       };
51074     } catch (...) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51077       };
51078     }
51079   }
51080
51081 }
51082
51083
51084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51085   void * jresult ;
51086   Dali::Vector< int > *arg1 = 0 ;
51087   Dali::Vector< int > *result = 0 ;
51088
51089   arg1 = (Dali::Vector< int > *)jarg1;
51090   if (!arg1) {
51091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51092     return 0;
51093   }
51094   {
51095     try {
51096       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51104       };
51105     } catch (Dali::DaliException e) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51108       };
51109     } catch (...) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51112       };
51113     }
51114   }
51115
51116   jresult = (void *)result;
51117   return jresult;
51118 }
51119
51120
51121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51122   void * jresult ;
51123   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51124   Dali::Vector< int > *arg2 = 0 ;
51125   Dali::Vector< int > *result = 0 ;
51126
51127   arg1 = (Dali::Vector< int > *)jarg1;
51128   arg2 = (Dali::Vector< int > *)jarg2;
51129   if (!arg2) {
51130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51131     return 0;
51132   }
51133   {
51134     try {
51135       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51136     } catch (std::out_of_range& e) {
51137       {
51138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51139       };
51140     } catch (std::exception& e) {
51141       {
51142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51143       };
51144     } catch (Dali::DaliException e) {
51145       {
51146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51147       };
51148     } catch (...) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51151       };
51152     }
51153   }
51154
51155   jresult = (void *)result;
51156   return jresult;
51157 }
51158
51159
51160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51161   void * jresult ;
51162   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51163   Dali::Vector< int >::Iterator result;
51164
51165   arg1 = (Dali::Vector< int > *)jarg1;
51166   {
51167     try {
51168       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51169     } catch (std::out_of_range& e) {
51170       {
51171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51172       };
51173     } catch (std::exception& e) {
51174       {
51175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (Dali::DaliException e) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51180       };
51181     } catch (...) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51184       };
51185     }
51186   }
51187
51188   jresult = (void *)result;
51189   return jresult;
51190 }
51191
51192
51193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51194   void * jresult ;
51195   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51196   Dali::Vector< int >::Iterator result;
51197
51198   arg1 = (Dali::Vector< int > *)jarg1;
51199   {
51200     try {
51201       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51202     } catch (std::out_of_range& e) {
51203       {
51204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51205       };
51206     } catch (std::exception& e) {
51207       {
51208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51209       };
51210     } catch (Dali::DaliException e) {
51211       {
51212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51213       };
51214     } catch (...) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51217       };
51218     }
51219   }
51220
51221   jresult = (void *)result;
51222   return jresult;
51223 }
51224
51225
51226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51227   void * jresult ;
51228   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51229   Dali::Vector< int >::SizeType arg2 ;
51230   Dali::Vector< int >::ItemType *result = 0 ;
51231
51232   arg1 = (Dali::Vector< int > *)jarg1;
51233   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51234   {
51235     try {
51236       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51237     } catch (std::out_of_range& e) {
51238       {
51239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (std::exception& e) {
51242       {
51243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51244       };
51245     } catch (Dali::DaliException e) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51248       };
51249     } catch (...) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51252       };
51253     }
51254   }
51255
51256   jresult = (void *)result;
51257   return jresult;
51258 }
51259
51260
51261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51262   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51263   Dali::Vector< int >::ItemType *arg2 = 0 ;
51264   Dali::Vector< int >::ItemType temp2 ;
51265
51266   arg1 = (Dali::Vector< int > *)jarg1;
51267   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51268   arg2 = &temp2;
51269   {
51270     try {
51271       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51272     } catch (std::out_of_range& e) {
51273       {
51274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51275       };
51276     } catch (std::exception& e) {
51277       {
51278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (Dali::DaliException e) {
51281       {
51282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51283       };
51284     } catch (...) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51287       };
51288     }
51289   }
51290
51291 }
51292
51293
51294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51295   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51296   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51297   Dali::Vector< int >::ItemType *arg3 = 0 ;
51298   Dali::Vector< int >::ItemType temp3 ;
51299
51300   arg1 = (Dali::Vector< int > *)jarg1;
51301   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51302   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51303   arg3 = &temp3;
51304   {
51305     try {
51306       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51307     } catch (std::out_of_range& e) {
51308       {
51309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51310       };
51311     } catch (std::exception& e) {
51312       {
51313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (Dali::DaliException e) {
51316       {
51317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51318       };
51319     } catch (...) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51322       };
51323     }
51324   }
51325
51326 }
51327
51328
51329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51330   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51331   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51332   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51333   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51334
51335   arg1 = (Dali::Vector< int > *)jarg1;
51336   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51337   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51338   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51339   {
51340     try {
51341       (arg1)->Insert(arg2,arg3,arg4);
51342     } catch (std::out_of_range& e) {
51343       {
51344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51345       };
51346     } catch (std::exception& e) {
51347       {
51348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51349       };
51350     } catch (Dali::DaliException e) {
51351       {
51352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51353       };
51354     } catch (...) {
51355       {
51356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51357       };
51358     }
51359   }
51360
51361 }
51362
51363
51364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51365   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51366   Dali::Vector< int >::SizeType arg2 ;
51367
51368   arg1 = (Dali::Vector< int > *)jarg1;
51369   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51370   {
51371     try {
51372       (arg1)->Reserve(arg2);
51373     } catch (std::out_of_range& e) {
51374       {
51375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51376       };
51377     } catch (std::exception& e) {
51378       {
51379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51380       };
51381     } catch (Dali::DaliException e) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51384       };
51385     } catch (...) {
51386       {
51387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51388       };
51389     }
51390   }
51391
51392 }
51393
51394
51395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51396   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51397   Dali::Vector< int >::SizeType arg2 ;
51398
51399   arg1 = (Dali::Vector< int > *)jarg1;
51400   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51401   {
51402     try {
51403       (arg1)->Resize(arg2);
51404     } catch (std::out_of_range& e) {
51405       {
51406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51407       };
51408     } catch (std::exception& e) {
51409       {
51410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (Dali::DaliException e) {
51413       {
51414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51415       };
51416     } catch (...) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51419       };
51420     }
51421   }
51422
51423 }
51424
51425
51426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51427   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51428   Dali::Vector< int >::SizeType arg2 ;
51429   Dali::Vector< int >::ItemType *arg3 = 0 ;
51430   Dali::Vector< int >::ItemType temp3 ;
51431
51432   arg1 = (Dali::Vector< int > *)jarg1;
51433   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51434   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51435   arg3 = &temp3;
51436   {
51437     try {
51438       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51439     } catch (std::out_of_range& e) {
51440       {
51441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (std::exception& e) {
51444       {
51445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (Dali::DaliException e) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51450       };
51451     } catch (...) {
51452       {
51453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51454       };
51455     }
51456   }
51457
51458 }
51459
51460
51461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51462   void * jresult ;
51463   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51464   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51465   Dali::Vector< int >::Iterator result;
51466
51467   arg1 = (Dali::Vector< int > *)jarg1;
51468   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51469   {
51470     try {
51471       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51472     } catch (std::out_of_range& e) {
51473       {
51474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51475       };
51476     } catch (std::exception& e) {
51477       {
51478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (Dali::DaliException e) {
51481       {
51482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51483       };
51484     } catch (...) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51487       };
51488     }
51489   }
51490
51491   jresult = (void *)result;
51492   return jresult;
51493 }
51494
51495
51496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51497   void * jresult ;
51498   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51499   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51500   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51501   Dali::Vector< int >::Iterator result;
51502
51503   arg1 = (Dali::Vector< int > *)jarg1;
51504   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51505   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51506   {
51507     try {
51508       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51509     } catch (std::out_of_range& e) {
51510       {
51511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51512       };
51513     } catch (std::exception& e) {
51514       {
51515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51516       };
51517     } catch (Dali::DaliException e) {
51518       {
51519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51520       };
51521     } catch (...) {
51522       {
51523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51524       };
51525     }
51526   }
51527
51528   jresult = (void *)result;
51529   return jresult;
51530 }
51531
51532
51533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51534   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51535   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51536
51537   arg1 = (Dali::Vector< int > *)jarg1;
51538   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51539   {
51540     try {
51541       (arg1)->Remove(arg2);
51542     } catch (std::out_of_range& e) {
51543       {
51544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51545       };
51546     } catch (std::exception& e) {
51547       {
51548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51549       };
51550     } catch (Dali::DaliException e) {
51551       {
51552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51553       };
51554     } catch (...) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51557       };
51558     }
51559   }
51560
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51565   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51566   Dali::Vector< int > *arg2 = 0 ;
51567
51568   arg1 = (Dali::Vector< int > *)jarg1;
51569   arg2 = (Dali::Vector< int > *)jarg2;
51570   if (!arg2) {
51571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51572     return ;
51573   }
51574   {
51575     try {
51576       (arg1)->Swap(*arg2);
51577     } catch (std::out_of_range& e) {
51578       {
51579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51580       };
51581     } catch (std::exception& e) {
51582       {
51583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (Dali::DaliException e) {
51586       {
51587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51588       };
51589     } catch (...) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51592       };
51593     }
51594   }
51595
51596 }
51597
51598
51599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51600   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51601
51602   arg1 = (Dali::Vector< int > *)jarg1;
51603   {
51604     try {
51605       (arg1)->Clear();
51606     } catch (std::out_of_range& e) {
51607       {
51608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51609       };
51610     } catch (std::exception& e) {
51611       {
51612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (Dali::DaliException e) {
51615       {
51616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51617       };
51618     } catch (...) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51621       };
51622     }
51623   }
51624
51625 }
51626
51627
51628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51629   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51630
51631   arg1 = (Dali::Vector< int > *)jarg1;
51632   {
51633     try {
51634       (arg1)->Release();
51635     } catch (std::out_of_range& e) {
51636       {
51637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (std::exception& e) {
51640       {
51641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (Dali::DaliException e) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51646       };
51647     } catch (...) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51650       };
51651     }
51652   }
51653
51654 }
51655
51656
51657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51658   int jresult ;
51659   int result;
51660
51661   result = (int)Dali::Vector< float >::BaseType;
51662   jresult = (int)result;
51663   return jresult;
51664 }
51665
51666
51667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51668   void * jresult ;
51669   Dali::Vector< float > *result = 0 ;
51670
51671   {
51672     try {
51673       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51674     } catch (std::out_of_range& e) {
51675       {
51676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51677       };
51678     } catch (std::exception& e) {
51679       {
51680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (Dali::DaliException e) {
51683       {
51684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51685       };
51686     } catch (...) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51689       };
51690     }
51691   }
51692
51693   jresult = (void *)result;
51694   return jresult;
51695 }
51696
51697
51698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51699   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51700
51701   arg1 = (Dali::Vector< float > *)jarg1;
51702   {
51703     try {
51704       delete arg1;
51705     } catch (std::out_of_range& e) {
51706       {
51707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51708       };
51709     } catch (std::exception& e) {
51710       {
51711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51712       };
51713     } catch (Dali::DaliException e) {
51714       {
51715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51716       };
51717     } catch (...) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51720       };
51721     }
51722   }
51723
51724 }
51725
51726
51727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51728   void * jresult ;
51729   Dali::Vector< float > *arg1 = 0 ;
51730   Dali::Vector< float > *result = 0 ;
51731
51732   arg1 = (Dali::Vector< float > *)jarg1;
51733   if (!arg1) {
51734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51735     return 0;
51736   }
51737   {
51738     try {
51739       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51740     } catch (std::out_of_range& e) {
51741       {
51742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51743       };
51744     } catch (std::exception& e) {
51745       {
51746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51747       };
51748     } catch (Dali::DaliException e) {
51749       {
51750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51751       };
51752     } catch (...) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51755       };
51756     }
51757   }
51758
51759   jresult = (void *)result;
51760   return jresult;
51761 }
51762
51763
51764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51765   void * jresult ;
51766   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51767   Dali::Vector< float > *arg2 = 0 ;
51768   Dali::Vector< float > *result = 0 ;
51769
51770   arg1 = (Dali::Vector< float > *)jarg1;
51771   arg2 = (Dali::Vector< float > *)jarg2;
51772   if (!arg2) {
51773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51774     return 0;
51775   }
51776   {
51777     try {
51778       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51779     } catch (std::out_of_range& e) {
51780       {
51781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51782       };
51783     } catch (std::exception& e) {
51784       {
51785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (Dali::DaliException e) {
51788       {
51789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51790       };
51791     } catch (...) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51794       };
51795     }
51796   }
51797
51798   jresult = (void *)result;
51799   return jresult;
51800 }
51801
51802
51803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51804   void * jresult ;
51805   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51806   Dali::Vector< float >::Iterator result;
51807
51808   arg1 = (Dali::Vector< float > *)jarg1;
51809   {
51810     try {
51811       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51812     } catch (std::out_of_range& e) {
51813       {
51814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51815       };
51816     } catch (std::exception& e) {
51817       {
51818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (Dali::DaliException e) {
51821       {
51822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51823       };
51824     } catch (...) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51827       };
51828     }
51829   }
51830
51831   jresult = (void *)result;
51832   return jresult;
51833 }
51834
51835
51836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51837   void * jresult ;
51838   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51839   Dali::Vector< float >::Iterator result;
51840
51841   arg1 = (Dali::Vector< float > *)jarg1;
51842   {
51843     try {
51844       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51845     } catch (std::out_of_range& e) {
51846       {
51847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51848       };
51849     } catch (std::exception& e) {
51850       {
51851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51852       };
51853     } catch (Dali::DaliException e) {
51854       {
51855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51856       };
51857     } catch (...) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51860       };
51861     }
51862   }
51863
51864   jresult = (void *)result;
51865   return jresult;
51866 }
51867
51868
51869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51870   void * jresult ;
51871   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51872   Dali::Vector< float >::SizeType arg2 ;
51873   Dali::Vector< float >::ItemType *result = 0 ;
51874
51875   arg1 = (Dali::Vector< float > *)jarg1;
51876   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51877   {
51878     try {
51879       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51880     } catch (std::out_of_range& e) {
51881       {
51882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51883       };
51884     } catch (std::exception& e) {
51885       {
51886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (Dali::DaliException e) {
51889       {
51890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51891       };
51892     } catch (...) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51895       };
51896     }
51897   }
51898
51899   jresult = (void *)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51905   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51906   Dali::Vector< float >::ItemType *arg2 = 0 ;
51907   Dali::Vector< float >::ItemType temp2 ;
51908
51909   arg1 = (Dali::Vector< float > *)jarg1;
51910   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51911   arg2 = &temp2;
51912   {
51913     try {
51914       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51915     } catch (std::out_of_range& e) {
51916       {
51917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (std::exception& e) {
51920       {
51921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (Dali::DaliException e) {
51924       {
51925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51926       };
51927     } catch (...) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51930       };
51931     }
51932   }
51933
51934 }
51935
51936
51937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51938   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51939   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51940   Dali::Vector< float >::ItemType *arg3 = 0 ;
51941   Dali::Vector< float >::ItemType temp3 ;
51942
51943   arg1 = (Dali::Vector< float > *)jarg1;
51944   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51945   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51946   arg3 = &temp3;
51947   {
51948     try {
51949       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51950     } catch (std::out_of_range& e) {
51951       {
51952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51953       };
51954     } catch (std::exception& e) {
51955       {
51956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (Dali::DaliException e) {
51959       {
51960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51961       };
51962     } catch (...) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51965       };
51966     }
51967   }
51968
51969 }
51970
51971
51972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51973   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51974   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51975   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51976   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51977
51978   arg1 = (Dali::Vector< float > *)jarg1;
51979   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51980   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51981   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51982   {
51983     try {
51984       (arg1)->Insert(arg2,arg3,arg4);
51985     } catch (std::out_of_range& e) {
51986       {
51987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51988       };
51989     } catch (std::exception& e) {
51990       {
51991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51992       };
51993     } catch (Dali::DaliException e) {
51994       {
51995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51996       };
51997     } catch (...) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52000       };
52001     }
52002   }
52003
52004 }
52005
52006
52007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52008   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52009   Dali::Vector< float >::SizeType arg2 ;
52010
52011   arg1 = (Dali::Vector< float > *)jarg1;
52012   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52013   {
52014     try {
52015       (arg1)->Reserve(arg2);
52016     } catch (std::out_of_range& e) {
52017       {
52018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52019       };
52020     } catch (std::exception& e) {
52021       {
52022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52023       };
52024     } catch (Dali::DaliException e) {
52025       {
52026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52027       };
52028     } catch (...) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52031       };
52032     }
52033   }
52034
52035 }
52036
52037 //// ========================= end of part 2 =============================
52038
52039 //// ========================== start part 3 ===============================
52040
52041
52042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52043   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52044   Dali::Vector< float >::SizeType arg2 ;
52045
52046   arg1 = (Dali::Vector< float > *)jarg1;
52047   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52048   {
52049     try {
52050       (arg1)->Resize(arg2);
52051     } catch (std::out_of_range& e) {
52052       {
52053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52054       };
52055     } catch (std::exception& e) {
52056       {
52057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52058       };
52059     } catch (Dali::DaliException e) {
52060       {
52061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52062       };
52063     } catch (...) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52066       };
52067     }
52068   }
52069
52070 }
52071
52072
52073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52074   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52075   Dali::Vector< float >::SizeType arg2 ;
52076   Dali::Vector< float >::ItemType *arg3 = 0 ;
52077   Dali::Vector< float >::ItemType temp3 ;
52078
52079   arg1 = (Dali::Vector< float > *)jarg1;
52080   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52081   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52082   arg3 = &temp3;
52083   {
52084     try {
52085       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52086     } catch (std::out_of_range& e) {
52087       {
52088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52089       };
52090     } catch (std::exception& e) {
52091       {
52092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52093       };
52094     } catch (Dali::DaliException e) {
52095       {
52096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52097       };
52098     } catch (...) {
52099       {
52100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52101       };
52102     }
52103   }
52104
52105 }
52106
52107
52108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52109   void * jresult ;
52110   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52111   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52112   Dali::Vector< float >::Iterator result;
52113
52114   arg1 = (Dali::Vector< float > *)jarg1;
52115   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52116   {
52117     try {
52118       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52119     } catch (std::out_of_range& e) {
52120       {
52121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52122       };
52123     } catch (std::exception& e) {
52124       {
52125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52126       };
52127     } catch (Dali::DaliException e) {
52128       {
52129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52130       };
52131     } catch (...) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52134       };
52135     }
52136   }
52137
52138   jresult = (void *)result;
52139   return jresult;
52140 }
52141
52142
52143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52144   void * jresult ;
52145   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52146   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52147   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52148   Dali::Vector< float >::Iterator result;
52149
52150   arg1 = (Dali::Vector< float > *)jarg1;
52151   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52152   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52153   {
52154     try {
52155       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52156     } catch (std::out_of_range& e) {
52157       {
52158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52159       };
52160     } catch (std::exception& e) {
52161       {
52162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52163       };
52164     } catch (Dali::DaliException e) {
52165       {
52166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52167       };
52168     } catch (...) {
52169       {
52170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52171       };
52172     }
52173   }
52174
52175   jresult = (void *)result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52181   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52182   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52183
52184   arg1 = (Dali::Vector< float > *)jarg1;
52185   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52186   {
52187     try {
52188       (arg1)->Remove(arg2);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (Dali::DaliException e) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52200       };
52201     } catch (...) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52204       };
52205     }
52206   }
52207
52208 }
52209
52210
52211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52212   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52213   Dali::Vector< float > *arg2 = 0 ;
52214
52215   arg1 = (Dali::Vector< float > *)jarg1;
52216   arg2 = (Dali::Vector< float > *)jarg2;
52217   if (!arg2) {
52218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52219     return ;
52220   }
52221   {
52222     try {
52223       (arg1)->Swap(*arg2);
52224     } catch (std::out_of_range& e) {
52225       {
52226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (std::exception& e) {
52229       {
52230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (Dali::DaliException e) {
52233       {
52234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52235       };
52236     } catch (...) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52239       };
52240     }
52241   }
52242
52243 }
52244
52245
52246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52247   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52248
52249   arg1 = (Dali::Vector< float > *)jarg1;
52250   {
52251     try {
52252       (arg1)->Clear();
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (Dali::DaliException e) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52264       };
52265     } catch (...) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52268       };
52269     }
52270   }
52271
52272 }
52273
52274
52275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52276   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52277
52278   arg1 = (Dali::Vector< float > *)jarg1;
52279   {
52280     try {
52281       (arg1)->Release();
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (Dali::DaliException e) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52293       };
52294     } catch (...) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52297       };
52298     }
52299   }
52300
52301 }
52302
52303
52304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52305   int jresult ;
52306   int result;
52307
52308   result = (int)Dali::Vector< unsigned char >::BaseType;
52309   jresult = (int)result;
52310   return jresult;
52311 }
52312
52313
52314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52315   void * jresult ;
52316   Dali::Vector< unsigned char > *result = 0 ;
52317
52318   {
52319     try {
52320       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52321     } catch (std::out_of_range& e) {
52322       {
52323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52324       };
52325     } catch (std::exception& e) {
52326       {
52327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (Dali::DaliException e) {
52330       {
52331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52332       };
52333     } catch (...) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52336       };
52337     }
52338   }
52339
52340   jresult = (void *)result;
52341   return jresult;
52342 }
52343
52344
52345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52346   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52347
52348   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52349   {
52350     try {
52351       delete arg1;
52352     } catch (std::out_of_range& e) {
52353       {
52354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52355       };
52356     } catch (std::exception& e) {
52357       {
52358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (Dali::DaliException e) {
52361       {
52362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52363       };
52364     } catch (...) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52367       };
52368     }
52369   }
52370
52371 }
52372
52373
52374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52375   void * jresult ;
52376   Dali::Vector< unsigned char > *arg1 = 0 ;
52377   Dali::Vector< unsigned char > *result = 0 ;
52378
52379   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52380   if (!arg1) {
52381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52382     return 0;
52383   }
52384   {
52385     try {
52386       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52387     } catch (std::out_of_range& e) {
52388       {
52389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52390       };
52391     } catch (std::exception& e) {
52392       {
52393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52394       };
52395     } catch (Dali::DaliException e) {
52396       {
52397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52398       };
52399     } catch (...) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52402       };
52403     }
52404   }
52405
52406   jresult = (void *)result;
52407   return jresult;
52408 }
52409
52410
52411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52412   void * jresult ;
52413   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52414   Dali::Vector< unsigned char > *arg2 = 0 ;
52415   Dali::Vector< unsigned char > *result = 0 ;
52416
52417   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52418   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52419   if (!arg2) {
52420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52421     return 0;
52422   }
52423   {
52424     try {
52425       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52426     } catch (std::out_of_range& e) {
52427       {
52428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (std::exception& e) {
52431       {
52432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (Dali::DaliException e) {
52435       {
52436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52437       };
52438     } catch (...) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52441       };
52442     }
52443   }
52444
52445   jresult = (void *)result;
52446   return jresult;
52447 }
52448
52449
52450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52451   void * jresult ;
52452   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52453   Dali::Vector< unsigned char >::Iterator result;
52454
52455   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52456   {
52457     try {
52458       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52459     } catch (std::out_of_range& e) {
52460       {
52461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52462       };
52463     } catch (std::exception& e) {
52464       {
52465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52466       };
52467     } catch (Dali::DaliException e) {
52468       {
52469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52470       };
52471     } catch (...) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52474       };
52475     }
52476   }
52477
52478   jresult = (void *)result;
52479   return jresult;
52480 }
52481
52482
52483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52484   void * jresult ;
52485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52486   Dali::Vector< unsigned char >::Iterator result;
52487
52488   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52489   {
52490     try {
52491       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52492     } catch (std::out_of_range& e) {
52493       {
52494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52495       };
52496     } catch (std::exception& e) {
52497       {
52498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52499       };
52500     } catch (Dali::DaliException e) {
52501       {
52502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52503       };
52504     } catch (...) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52507       };
52508     }
52509   }
52510
52511   jresult = (void *)result;
52512   return jresult;
52513 }
52514
52515
52516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52517   void * jresult ;
52518   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52519   Dali::Vector< unsigned char >::SizeType arg2 ;
52520   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52521
52522   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52523   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52524   {
52525     try {
52526       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52527     } catch (std::out_of_range& e) {
52528       {
52529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52530       };
52531     } catch (std::exception& e) {
52532       {
52533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52534       };
52535     } catch (Dali::DaliException e) {
52536       {
52537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52538       };
52539     } catch (...) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52542       };
52543     }
52544   }
52545
52546   jresult = (void *)result;
52547   return jresult;
52548 }
52549
52550
52551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52552   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52553   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52554   Dali::Vector< unsigned char >::ItemType temp2 ;
52555
52556   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52557   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52558   arg2 = &temp2;
52559   {
52560     try {
52561       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52562     } catch (std::out_of_range& e) {
52563       {
52564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52565       };
52566     } catch (std::exception& e) {
52567       {
52568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (Dali::DaliException e) {
52571       {
52572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52573       };
52574     } catch (...) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52577       };
52578     }
52579   }
52580
52581 }
52582
52583
52584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52585   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52586   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52587   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52588   Dali::Vector< unsigned char >::ItemType temp3 ;
52589
52590   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52591   arg2 = jarg2;
52592   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52593   arg3 = &temp3;
52594   {
52595     try {
52596       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52597     } catch (std::out_of_range& e) {
52598       {
52599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52600       };
52601     } catch (std::exception& e) {
52602       {
52603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (Dali::DaliException e) {
52606       {
52607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52608       };
52609     } catch (...) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52612       };
52613     }
52614   }
52615
52616
52617
52618 }
52619
52620
52621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52622   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52623   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52624   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52625   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52626
52627   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52628   arg2 = jarg2;
52629   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52630   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52631   {
52632     try {
52633       (arg1)->Insert(arg2,arg3,arg4);
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52641       };
52642     } catch (Dali::DaliException e) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52645       };
52646     } catch (...) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52649       };
52650     }
52651   }
52652
52653
52654
52655 }
52656
52657
52658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52660   Dali::Vector< unsigned char >::SizeType arg2 ;
52661
52662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52663   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52664   {
52665     try {
52666       (arg1)->Reserve(arg2);
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (Dali::DaliException e) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52678       };
52679     } catch (...) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52682       };
52683     }
52684   }
52685
52686 }
52687
52688
52689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52690   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52691   Dali::Vector< unsigned char >::SizeType arg2 ;
52692
52693   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52694   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52695   {
52696     try {
52697       (arg1)->Resize(arg2);
52698     } catch (std::out_of_range& e) {
52699       {
52700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52701       };
52702     } catch (std::exception& e) {
52703       {
52704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (Dali::DaliException e) {
52707       {
52708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52709       };
52710     } catch (...) {
52711       {
52712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52713       };
52714     }
52715   }
52716
52717 }
52718
52719
52720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52722   Dali::Vector< unsigned char >::SizeType arg2 ;
52723   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52724   Dali::Vector< unsigned char >::ItemType temp3 ;
52725
52726   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52727   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52728   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52729   arg3 = &temp3;
52730   {
52731     try {
52732       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52733     } catch (std::out_of_range& e) {
52734       {
52735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52736       };
52737     } catch (std::exception& e) {
52738       {
52739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52740       };
52741     } catch (Dali::DaliException e) {
52742       {
52743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52744       };
52745     } catch (...) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52748       };
52749     }
52750   }
52751
52752 }
52753
52754
52755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52756   void * jresult ;
52757   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52758   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52759   Dali::Vector< unsigned char >::Iterator result;
52760
52761   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52762   arg2 = jarg2;
52763   {
52764     try {
52765       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (Dali::DaliException e) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52777       };
52778     } catch (...) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52781       };
52782     }
52783   }
52784
52785   jresult = (void *)result;
52786
52787
52788   return jresult;
52789 }
52790
52791
52792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52793   void * jresult ;
52794   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52795   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52796   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52797   Dali::Vector< unsigned char >::Iterator result;
52798
52799   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52800   arg2 = jarg2;
52801   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52802   {
52803     try {
52804       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52805     } catch (std::out_of_range& e) {
52806       {
52807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52808       };
52809     } catch (std::exception& e) {
52810       {
52811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (Dali::DaliException e) {
52814       {
52815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52816       };
52817     } catch (...) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52820       };
52821     }
52822   }
52823
52824   jresult = (void *)result;
52825
52826
52827   return jresult;
52828 }
52829
52830
52831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52832   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52833   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52834
52835   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52836   arg2 = jarg2;
52837   {
52838     try {
52839       (arg1)->Remove(arg2);
52840     } catch (std::out_of_range& e) {
52841       {
52842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52843       };
52844     } catch (std::exception& e) {
52845       {
52846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52847       };
52848     } catch (Dali::DaliException e) {
52849       {
52850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52851       };
52852     } catch (...) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52855       };
52856     }
52857   }
52858
52859
52860
52861 }
52862
52863
52864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52865   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52866   Dali::Vector< unsigned char > *arg2 = 0 ;
52867
52868   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52869   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52870   if (!arg2) {
52871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52872     return ;
52873   }
52874   {
52875     try {
52876       (arg1)->Swap(*arg2);
52877     } catch (std::out_of_range& e) {
52878       {
52879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52880       };
52881     } catch (std::exception& e) {
52882       {
52883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52884       };
52885     } catch (Dali::DaliException e) {
52886       {
52887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52888       };
52889     } catch (...) {
52890       {
52891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52892       };
52893     }
52894   }
52895
52896 }
52897
52898
52899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52900   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52901
52902   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52903   {
52904     try {
52905       (arg1)->Clear();
52906     } catch (std::out_of_range& e) {
52907       {
52908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52909       };
52910     } catch (std::exception& e) {
52911       {
52912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52913       };
52914     } catch (Dali::DaliException e) {
52915       {
52916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52917       };
52918     } catch (...) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52921       };
52922     }
52923   }
52924
52925 }
52926
52927
52928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52929   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52930
52931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52932   {
52933     try {
52934       (arg1)->Release();
52935     } catch (std::out_of_range& e) {
52936       {
52937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52938       };
52939     } catch (std::exception& e) {
52940       {
52941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (Dali::DaliException e) {
52944       {
52945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52950       };
52951     }
52952   }
52953
52954 }
52955
52956
52957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52958   int jresult ;
52959   int result;
52960
52961   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52962   jresult = (int)result;
52963   return jresult;
52964 }
52965
52966
52967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52968   void * jresult ;
52969   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52970
52971   {
52972     try {
52973       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52974     } catch (std::out_of_range& e) {
52975       {
52976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52977       };
52978     } catch (std::exception& e) {
52979       {
52980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (Dali::DaliException e) {
52983       {
52984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52985       };
52986     } catch (...) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52989       };
52990     }
52991   }
52992
52993   jresult = (void *)result;
52994   return jresult;
52995 }
52996
52997
52998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52999   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53000
53001   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53002   {
53003     try {
53004       delete arg1;
53005     } catch (std::out_of_range& e) {
53006       {
53007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53008       };
53009     } catch (std::exception& e) {
53010       {
53011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (Dali::DaliException e) {
53014       {
53015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53016       };
53017     } catch (...) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53020       };
53021     }
53022   }
53023
53024 }
53025
53026
53027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53028   void * jresult ;
53029   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53030   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53031
53032   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53033   if (!arg1) {
53034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53035     return 0;
53036   }
53037   {
53038     try {
53039       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53040     } catch (std::out_of_range& e) {
53041       {
53042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53043       };
53044     } catch (std::exception& e) {
53045       {
53046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (Dali::DaliException e) {
53049       {
53050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53055       };
53056     }
53057   }
53058
53059   jresult = (void *)result;
53060   return jresult;
53061 }
53062
53063
53064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53065   void * jresult ;
53066   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53067   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53068   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53069
53070   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53071   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53072   if (!arg2) {
53073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53074     return 0;
53075   }
53076   {
53077     try {
53078       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53079     } catch (std::out_of_range& e) {
53080       {
53081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53082       };
53083     } catch (std::exception& e) {
53084       {
53085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53086       };
53087     } catch (Dali::DaliException e) {
53088       {
53089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53090       };
53091     } catch (...) {
53092       {
53093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53094       };
53095     }
53096   }
53097
53098   jresult = (void *)result;
53099   return jresult;
53100 }
53101
53102
53103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53104   void * jresult ;
53105   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53106   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53107
53108   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53109   {
53110     try {
53111       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53112     } catch (std::out_of_range& e) {
53113       {
53114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53115       };
53116     } catch (std::exception& e) {
53117       {
53118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (Dali::DaliException e) {
53121       {
53122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53123       };
53124     } catch (...) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53127       };
53128     }
53129   }
53130
53131   jresult = (void *)result;
53132   return jresult;
53133 }
53134
53135
53136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53137   void * jresult ;
53138   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53139   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53140
53141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53142   {
53143     try {
53144       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53145     } catch (std::out_of_range& e) {
53146       {
53147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53148       };
53149     } catch (std::exception& e) {
53150       {
53151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53152       };
53153     } catch (Dali::DaliException e) {
53154       {
53155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53156       };
53157     } catch (...) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53160       };
53161     }
53162   }
53163
53164   jresult = (void *)result;
53165   return jresult;
53166 }
53167
53168
53169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53170   void * jresult ;
53171   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53172   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53173   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53174
53175   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53176   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53177   {
53178     try {
53179       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53180     } catch (std::out_of_range& e) {
53181       {
53182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53183       };
53184     } catch (std::exception& e) {
53185       {
53186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (Dali::DaliException e) {
53189       {
53190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53191       };
53192     } catch (...) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53195       };
53196     }
53197   }
53198
53199   jresult = (void *)result;
53200   return jresult;
53201 }
53202
53203
53204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53205   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53206   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53207
53208   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53209   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53210   if (!arg2) {
53211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53212     return ;
53213   }
53214   {
53215     try {
53216       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53217     } catch (std::out_of_range& e) {
53218       {
53219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53220       };
53221     } catch (std::exception& e) {
53222       {
53223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (Dali::DaliException e) {
53226       {
53227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53228       };
53229     } catch (...) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53232       };
53233     }
53234   }
53235
53236 }
53237
53238
53239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53240   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53241   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53242   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53243
53244   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53245   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53246   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53247   if (!arg3) {
53248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53249     return ;
53250   }
53251   {
53252     try {
53253       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53254     } catch (std::out_of_range& e) {
53255       {
53256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53257       };
53258     } catch (std::exception& e) {
53259       {
53260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (Dali::DaliException e) {
53263       {
53264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53265       };
53266     } catch (...) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53269       };
53270     }
53271   }
53272
53273 }
53274
53275
53276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53277   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53278   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53279   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53280   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53281
53282   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53283   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53284   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53285   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53286   {
53287     try {
53288       (arg1)->Insert(arg2,arg3,arg4);
53289     } catch (std::out_of_range& e) {
53290       {
53291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53292       };
53293     } catch (std::exception& e) {
53294       {
53295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53296       };
53297     } catch (Dali::DaliException e) {
53298       {
53299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53300       };
53301     } catch (...) {
53302       {
53303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53304       };
53305     }
53306   }
53307
53308 }
53309
53310
53311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53312   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53313   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53314
53315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53316   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53317   {
53318     try {
53319       (arg1)->Reserve(arg2);
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (Dali::DaliException e) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53331       };
53332     } catch (...) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53335       };
53336     }
53337   }
53338
53339 }
53340
53341
53342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53343   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53344   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53345
53346   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53347   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53348   {
53349     try {
53350       (arg1)->Resize(arg2);
53351     } catch (std::out_of_range& e) {
53352       {
53353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53354       };
53355     } catch (std::exception& e) {
53356       {
53357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (Dali::DaliException e) {
53360       {
53361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53362       };
53363     } catch (...) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53366       };
53367     }
53368   }
53369
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53374   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53375   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53376   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53377
53378   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53379   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53380   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53381   if (!arg3) {
53382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53383     return ;
53384   }
53385   {
53386     try {
53387       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53388     } catch (std::out_of_range& e) {
53389       {
53390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (std::exception& e) {
53393       {
53394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (Dali::DaliException e) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53399       };
53400     } catch (...) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53403       };
53404     }
53405   }
53406
53407 }
53408
53409
53410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53411   void * jresult ;
53412   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53413   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53414   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53415
53416   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53417   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53418   {
53419     try {
53420       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53421     } catch (std::out_of_range& e) {
53422       {
53423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53424       };
53425     } catch (std::exception& e) {
53426       {
53427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53428       };
53429     } catch (Dali::DaliException e) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53432       };
53433     } catch (...) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53436       };
53437     }
53438   }
53439
53440   jresult = (void *)result;
53441   return jresult;
53442 }
53443
53444
53445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53446   void * jresult ;
53447   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53449   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53450   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53451
53452   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53453   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53454   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53455   {
53456     try {
53457       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53458     } catch (std::out_of_range& e) {
53459       {
53460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53461       };
53462     } catch (std::exception& e) {
53463       {
53464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53465       };
53466     } catch (Dali::DaliException e) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53469       };
53470     } catch (...) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53473       };
53474     }
53475   }
53476
53477   jresult = (void *)result;
53478   return jresult;
53479 }
53480
53481
53482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53483   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53484   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53485
53486   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53487   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53488   {
53489     try {
53490       (arg1)->Remove(arg2);
53491     } catch (std::out_of_range& e) {
53492       {
53493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53494       };
53495     } catch (std::exception& e) {
53496       {
53497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53498       };
53499     } catch (Dali::DaliException e) {
53500       {
53501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53502       };
53503     } catch (...) {
53504       {
53505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53506       };
53507     }
53508   }
53509
53510 }
53511
53512
53513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53514   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53515   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53516
53517   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53518   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53519   if (!arg2) {
53520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53521     return ;
53522   }
53523   {
53524     try {
53525       (arg1)->Swap(*arg2);
53526     } catch (std::out_of_range& e) {
53527       {
53528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53529       };
53530     } catch (std::exception& e) {
53531       {
53532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53533       };
53534     } catch (Dali::DaliException e) {
53535       {
53536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53537       };
53538     } catch (...) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53541       };
53542     }
53543   }
53544
53545 }
53546
53547
53548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53549   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53550
53551   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53552   {
53553     try {
53554       (arg1)->Clear();
53555     } catch (std::out_of_range& e) {
53556       {
53557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (std::exception& e) {
53560       {
53561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (Dali::DaliException e) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53566       };
53567     } catch (...) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53570       };
53571     }
53572   }
53573
53574 }
53575
53576
53577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53578   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53579
53580   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53581   {
53582     try {
53583       (arg1)->Release();
53584     } catch (std::out_of_range& e) {
53585       {
53586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53587       };
53588     } catch (std::exception& e) {
53589       {
53590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53591       };
53592     } catch (Dali::DaliException e) {
53593       {
53594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53595       };
53596     } catch (...) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53599       };
53600     }
53601   }
53602
53603 }
53604
53605
53606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53607   void * jresult ;
53608   Dali::Signal< void () > *result = 0 ;
53609
53610   {
53611     try {
53612       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53613     } catch (std::out_of_range& e) {
53614       {
53615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53616       };
53617     } catch (std::exception& e) {
53618       {
53619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53620       };
53621     } catch (Dali::DaliException e) {
53622       {
53623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53624       };
53625     } catch (...) {
53626       {
53627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53628       };
53629     }
53630   }
53631
53632   jresult = (void *)result;
53633   return jresult;
53634 }
53635
53636
53637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53638   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53639
53640   arg1 = (Dali::Signal< void () > *)jarg1;
53641   {
53642     try {
53643       delete arg1;
53644     } catch (std::out_of_range& e) {
53645       {
53646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53647       };
53648     } catch (std::exception& e) {
53649       {
53650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (Dali::DaliException e) {
53653       {
53654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53655       };
53656     } catch (...) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53659       };
53660     }
53661   }
53662
53663 }
53664
53665
53666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53667   unsigned int jresult ;
53668   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53669   bool result;
53670
53671   arg1 = (Dali::Signal< void () > *)jarg1;
53672   {
53673     try {
53674       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53675     } catch (std::out_of_range& e) {
53676       {
53677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53678       };
53679     } catch (std::exception& e) {
53680       {
53681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53682       };
53683     } catch (Dali::DaliException e) {
53684       {
53685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53686       };
53687     } catch (...) {
53688       {
53689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53690       };
53691     }
53692   }
53693
53694   jresult = result;
53695   return jresult;
53696 }
53697
53698
53699 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53700   unsigned long jresult ;
53701   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53702   std::size_t result;
53703
53704   arg1 = (Dali::Signal< void () > *)jarg1;
53705   {
53706     try {
53707       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53708     } catch (std::out_of_range& e) {
53709       {
53710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53711       };
53712     } catch (std::exception& e) {
53713       {
53714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (Dali::DaliException e) {
53717       {
53718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53719       };
53720     } catch (...) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53723       };
53724     }
53725   }
53726
53727   jresult = (unsigned long)result;
53728   return jresult;
53729 }
53730
53731
53732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53733   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53734   void (*arg2)() = (void (*)()) 0 ;
53735
53736   arg1 = (Dali::Signal< void () > *)jarg1;
53737   arg2 = (void (*)())jarg2;
53738   {
53739     try {
53740       (arg1)->Connect(arg2);
53741     } catch (std::out_of_range& e) {
53742       {
53743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53744       };
53745     } catch (std::exception& e) {
53746       {
53747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53748       };
53749     } catch (Dali::DaliException e) {
53750       {
53751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53752       };
53753     } catch (...) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53756       };
53757     }
53758   }
53759
53760 }
53761
53762
53763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53764   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53765   void (*arg2)() = (void (*)()) 0 ;
53766
53767   arg1 = (Dali::Signal< void () > *)jarg1;
53768   arg2 = (void (*)())jarg2;
53769   {
53770     try {
53771       (arg1)->Disconnect(arg2);
53772     } catch (std::out_of_range& e) {
53773       {
53774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53775       };
53776     } catch (std::exception& e) {
53777       {
53778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53779       };
53780     } catch (Dali::DaliException e) {
53781       {
53782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53783       };
53784     } catch (...) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53787       };
53788     }
53789   }
53790
53791 }
53792
53793
53794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53795   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53796   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53797   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53798
53799   arg1 = (Dali::Signal< void () > *)jarg1;
53800   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53801   arg3 = (Dali::FunctorDelegate *)jarg3;
53802   {
53803     try {
53804       (arg1)->Connect(arg2,arg3);
53805     } catch (std::out_of_range& e) {
53806       {
53807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53808       };
53809     } catch (std::exception& e) {
53810       {
53811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (Dali::DaliException e) {
53814       {
53815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53816       };
53817     } catch (...) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53820       };
53821     }
53822   }
53823
53824 }
53825
53826
53827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53828   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53829
53830   arg1 = (Dali::Signal< void () > *)jarg1;
53831   {
53832     try {
53833       (arg1)->Emit();
53834     } catch (std::out_of_range& e) {
53835       {
53836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53837       };
53838     } catch (std::exception& e) {
53839       {
53840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53841       };
53842     } catch (Dali::DaliException e) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53845       };
53846     } catch (...) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53849       };
53850     }
53851   }
53852
53853 }
53854
53855
53856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53857   unsigned int jresult ;
53858   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53859   bool result;
53860
53861   arg1 = (Dali::Signal< void (float) > *)jarg1;
53862   {
53863     try {
53864       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53865     } catch (std::out_of_range& e) {
53866       {
53867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53868       };
53869     } catch (std::exception& e) {
53870       {
53871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53872       };
53873     } catch (Dali::DaliException e) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53876       };
53877     } catch (...) {
53878       {
53879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53880       };
53881     }
53882   }
53883
53884   jresult = result;
53885   return jresult;
53886 }
53887
53888
53889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53890   unsigned long jresult ;
53891   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53892   std::size_t result;
53893
53894   arg1 = (Dali::Signal< void (float) > *)jarg1;
53895   {
53896     try {
53897       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53898     } catch (std::out_of_range& e) {
53899       {
53900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53901       };
53902     } catch (std::exception& e) {
53903       {
53904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53905       };
53906     } catch (Dali::DaliException e) {
53907       {
53908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53909       };
53910     } catch (...) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53913       };
53914     }
53915   }
53916
53917   jresult = (unsigned long)result;
53918   return jresult;
53919 }
53920
53921
53922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53923   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53924   void (*arg2)(float) = (void (*)(float)) 0 ;
53925
53926   arg1 = (Dali::Signal< void (float) > *)jarg1;
53927   arg2 = (void (*)(float))jarg2;
53928   {
53929     try {
53930       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53931     } catch (std::out_of_range& e) {
53932       {
53933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53934       };
53935     } catch (std::exception& e) {
53936       {
53937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (Dali::DaliException e) {
53940       {
53941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53942       };
53943     } catch (...) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53946       };
53947     }
53948   }
53949
53950 }
53951
53952
53953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53954   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53955   void (*arg2)(float) = (void (*)(float)) 0 ;
53956
53957   arg1 = (Dali::Signal< void (float) > *)jarg1;
53958   arg2 = (void (*)(float))jarg2;
53959   {
53960     try {
53961       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53962     } catch (std::out_of_range& e) {
53963       {
53964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53965       };
53966     } catch (std::exception& e) {
53967       {
53968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (Dali::DaliException e) {
53971       {
53972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53977       };
53978     }
53979   }
53980
53981 }
53982
53983
53984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53985   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53986   float arg2 ;
53987
53988   arg1 = (Dali::Signal< void (float) > *)jarg1;
53989   arg2 = (float)jarg2;
53990   {
53991     try {
53992       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53993     } catch (std::out_of_range& e) {
53994       {
53995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53996       };
53997     } catch (std::exception& e) {
53998       {
53999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (Dali::DaliException e) {
54002       {
54003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54004       };
54005     } catch (...) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54008       };
54009     }
54010   }
54011
54012 }
54013
54014
54015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54016   void * jresult ;
54017   Dali::Signal< void (float) > *result = 0 ;
54018
54019   {
54020     try {
54021       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54022     } catch (std::out_of_range& e) {
54023       {
54024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54025       };
54026     } catch (std::exception& e) {
54027       {
54028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54029       };
54030     } catch (Dali::DaliException e) {
54031       {
54032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54037       };
54038     }
54039   }
54040
54041   jresult = (void *)result;
54042   return jresult;
54043 }
54044
54045
54046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54047   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54048
54049   arg1 = (Dali::Signal< void (float) > *)jarg1;
54050   {
54051     try {
54052       delete arg1;
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (Dali::DaliException e) {
54062       {
54063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54068       };
54069     }
54070   }
54071
54072 }
54073
54074
54075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54076   unsigned int jresult ;
54077   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54078   bool result;
54079
54080   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54081   {
54082     try {
54083       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54084     } catch (std::out_of_range& e) {
54085       {
54086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54087       };
54088     } catch (std::exception& e) {
54089       {
54090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54091       };
54092     } catch (Dali::DaliException e) {
54093       {
54094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54095       };
54096     } catch (...) {
54097       {
54098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54099       };
54100     }
54101   }
54102
54103   jresult = result;
54104   return jresult;
54105 }
54106
54107
54108 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54109   unsigned long jresult ;
54110   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54111   std::size_t result;
54112
54113   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54114   {
54115     try {
54116       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54117     } catch (std::out_of_range& e) {
54118       {
54119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54120       };
54121     } catch (std::exception& e) {
54122       {
54123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54124       };
54125     } catch (Dali::DaliException e) {
54126       {
54127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54128       };
54129     } catch (...) {
54130       {
54131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54132       };
54133     }
54134   }
54135
54136   jresult = (unsigned long)result;
54137   return jresult;
54138 }
54139
54140
54141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54142   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54143   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54144
54145   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54146   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54147   {
54148     try {
54149       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54150     } catch (std::out_of_range& e) {
54151       {
54152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54153       };
54154     } catch (std::exception& e) {
54155       {
54156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (Dali::DaliException e) {
54159       {
54160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54161       };
54162     } catch (...) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54165       };
54166     }
54167   }
54168
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54173   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54174   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54175
54176   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54177   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54178   {
54179     try {
54180       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54181     } catch (std::out_of_range& e) {
54182       {
54183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (std::exception& e) {
54186       {
54187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (Dali::DaliException e) {
54190       {
54191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54192       };
54193     } catch (...) {
54194       {
54195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54196       };
54197     }
54198   }
54199
54200 }
54201
54202
54203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54204   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54205   Dali::BaseHandle arg2 ;
54206   Dali::BaseHandle *argp2 ;
54207
54208   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54209   argp2 = (Dali::BaseHandle *)jarg2;
54210   if (!argp2) {
54211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54212     return ;
54213   }
54214   arg2 = *argp2;
54215   {
54216     try {
54217       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54218     } catch (std::out_of_range& e) {
54219       {
54220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54221       };
54222     } catch (std::exception& e) {
54223       {
54224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (Dali::DaliException e) {
54227       {
54228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54229       };
54230     } catch (...) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54233       };
54234     }
54235   }
54236
54237 }
54238
54239
54240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54241   void * jresult ;
54242   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54243
54244   {
54245     try {
54246       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54247     } catch (std::out_of_range& e) {
54248       {
54249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (std::exception& e) {
54252       {
54253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (Dali::DaliException e) {
54256       {
54257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54258       };
54259     } catch (...) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54262       };
54263     }
54264   }
54265
54266   jresult = (void *)result;
54267   return jresult;
54268 }
54269
54270
54271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54272   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54273
54274   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54275   {
54276     try {
54277       delete arg1;
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (Dali::DaliException e) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54289       };
54290     } catch (...) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54293       };
54294     }
54295   }
54296
54297 }
54298
54299
54300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54301   unsigned int jresult ;
54302   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54303   bool result;
54304
54305   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54306   {
54307     try {
54308       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (Dali::DaliException e) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54320       };
54321     } catch (...) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54324       };
54325     }
54326   }
54327
54328   jresult = result;
54329   return jresult;
54330 }
54331
54332
54333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54334   unsigned long jresult ;
54335   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54336   std::size_t result;
54337
54338   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54339   {
54340     try {
54341       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54342     } catch (std::out_of_range& e) {
54343       {
54344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54345       };
54346     } catch (std::exception& e) {
54347       {
54348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (Dali::DaliException e) {
54351       {
54352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54353       };
54354     } catch (...) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54357       };
54358     }
54359   }
54360
54361   jresult = (unsigned long)result;
54362   return jresult;
54363 }
54364
54365
54366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54367   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54368   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54369
54370   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54371   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54372   {
54373     try {
54374       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54375     } catch (std::out_of_range& e) {
54376       {
54377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54378       };
54379     } catch (std::exception& e) {
54380       {
54381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (Dali::DaliException e) {
54384       {
54385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54386       };
54387     } catch (...) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54390       };
54391     }
54392   }
54393
54394 }
54395
54396
54397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54398   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54399   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54400
54401   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54402   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54403   {
54404     try {
54405       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54406     } catch (std::out_of_range& e) {
54407       {
54408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54409       };
54410     } catch (std::exception& e) {
54411       {
54412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (Dali::DaliException e) {
54415       {
54416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54417       };
54418     } catch (...) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54421       };
54422     }
54423   }
54424
54425 }
54426
54427
54428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54429   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54430   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54431
54432   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54433   arg2 = (Dali::RefObject *)jarg2;
54434   {
54435     try {
54436       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54437     } catch (std::out_of_range& e) {
54438       {
54439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54440       };
54441     } catch (std::exception& e) {
54442       {
54443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (Dali::DaliException e) {
54446       {
54447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54448       };
54449     } catch (...) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54452       };
54453     }
54454   }
54455
54456 }
54457
54458
54459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54460   void * jresult ;
54461   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54462
54463   {
54464     try {
54465       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54466     } catch (std::out_of_range& e) {
54467       {
54468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54469       };
54470     } catch (std::exception& e) {
54471       {
54472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54473       };
54474     } catch (Dali::DaliException e) {
54475       {
54476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54477       };
54478     } catch (...) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54481       };
54482     }
54483   }
54484
54485   jresult = (void *)result;
54486   return jresult;
54487 }
54488
54489
54490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54491   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54492
54493   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54494   {
54495     try {
54496       delete arg1;
54497     } catch (std::out_of_range& e) {
54498       {
54499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54500       };
54501     } catch (std::exception& e) {
54502       {
54503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54504       };
54505     } catch (Dali::DaliException e) {
54506       {
54507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54508       };
54509     } catch (...) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54512       };
54513     }
54514   }
54515
54516 }
54517
54518
54519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54520   unsigned int jresult ;
54521   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54522   bool result;
54523
54524   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54525   {
54526     try {
54527       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54528     } catch (std::out_of_range& e) {
54529       {
54530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54531       };
54532     } catch (std::exception& e) {
54533       {
54534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54535       };
54536     } catch (Dali::DaliException e) {
54537       {
54538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54539       };
54540     } catch (...) {
54541       {
54542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54543       };
54544     }
54545   }
54546
54547   jresult = result;
54548   return jresult;
54549 }
54550
54551
54552 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54553   unsigned long jresult ;
54554   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54555   std::size_t result;
54556
54557   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54558   {
54559     try {
54560       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54561     } catch (std::out_of_range& e) {
54562       {
54563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54564       };
54565     } catch (std::exception& e) {
54566       {
54567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (Dali::DaliException e) {
54570       {
54571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54572       };
54573     } catch (...) {
54574       {
54575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54576       };
54577     }
54578   }
54579
54580   jresult = (unsigned long)result;
54581   return jresult;
54582 }
54583
54584
54585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54586   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54587   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54588
54589   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54590   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54591   {
54592     try {
54593       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54594     } catch (std::out_of_range& e) {
54595       {
54596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54597       };
54598     } catch (std::exception& e) {
54599       {
54600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (Dali::DaliException e) {
54603       {
54604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54605       };
54606     } catch (...) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54609       };
54610     }
54611   }
54612
54613 }
54614
54615
54616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54617   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54618   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54619
54620   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54621   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54622   {
54623     try {
54624       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54625     } catch (std::out_of_range& e) {
54626       {
54627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (std::exception& e) {
54630       {
54631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (Dali::DaliException e) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54636       };
54637     } catch (...) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54640       };
54641     }
54642   }
54643
54644 }
54645
54646
54647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54648   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54649   Dali::PropertyNotification *arg2 = 0 ;
54650
54651   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54652   arg2 = (Dali::PropertyNotification *)jarg2;
54653   if (!arg2) {
54654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54655     return ;
54656   }
54657   {
54658     try {
54659       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54660     } catch (std::out_of_range& e) {
54661       {
54662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54663       };
54664     } catch (std::exception& e) {
54665       {
54666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54667       };
54668     } catch (Dali::DaliException e) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54671       };
54672     } catch (...) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54675       };
54676     }
54677   }
54678
54679 }
54680
54681
54682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54683   void * jresult ;
54684   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54685
54686   {
54687     try {
54688       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54689     } catch (std::out_of_range& e) {
54690       {
54691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54692       };
54693     } catch (std::exception& e) {
54694       {
54695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54696       };
54697     } catch (Dali::DaliException e) {
54698       {
54699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54700       };
54701     } catch (...) {
54702       {
54703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54704       };
54705     }
54706   }
54707
54708   jresult = (void *)result;
54709   return jresult;
54710 }
54711
54712
54713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54714   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54715
54716   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54717   {
54718     try {
54719       delete arg1;
54720     } catch (std::out_of_range& e) {
54721       {
54722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54723       };
54724     } catch (std::exception& e) {
54725       {
54726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54727       };
54728     } catch (Dali::DaliException e) {
54729       {
54730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54731       };
54732     } catch (...) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54735       };
54736     }
54737   }
54738
54739 }
54740
54741
54742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54743   unsigned int jresult ;
54744   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54745   bool result;
54746
54747   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54748   {
54749     try {
54750       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54751     } catch (std::out_of_range& e) {
54752       {
54753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (std::exception& e) {
54756       {
54757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (Dali::DaliException e) {
54760       {
54761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54762       };
54763     } catch (...) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54766       };
54767     }
54768   }
54769
54770   jresult = result;
54771   return jresult;
54772 }
54773
54774
54775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54776   unsigned long jresult ;
54777   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54778   std::size_t result;
54779
54780   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54781   {
54782     try {
54783       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54784     } catch (std::out_of_range& e) {
54785       {
54786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54787       };
54788     } catch (std::exception& e) {
54789       {
54790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (Dali::DaliException e) {
54793       {
54794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54795       };
54796     } catch (...) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54799       };
54800     }
54801   }
54802
54803   jresult = (unsigned long)result;
54804   return jresult;
54805 }
54806
54807
54808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54809   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54810   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54811
54812   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54813   arg2 = (void (*)(Dali::Image))jarg2;
54814   {
54815     try {
54816       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54817     } catch (std::out_of_range& e) {
54818       {
54819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54820       };
54821     } catch (std::exception& e) {
54822       {
54823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54824       };
54825     } catch (Dali::DaliException e) {
54826       {
54827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54828       };
54829     } catch (...) {
54830       {
54831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54832       };
54833     }
54834   }
54835
54836 }
54837
54838
54839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54840   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54841   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54842
54843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54844   arg2 = (void (*)(Dali::Image))jarg2;
54845   {
54846     try {
54847       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54848     } catch (std::out_of_range& e) {
54849       {
54850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54851       };
54852     } catch (std::exception& e) {
54853       {
54854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54855       };
54856     } catch (Dali::DaliException e) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54859       };
54860     } catch (...) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54863       };
54864     }
54865   }
54866
54867 }
54868
54869
54870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54871   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54872   Dali::Image arg2 ;
54873   Dali::Image *argp2 ;
54874
54875   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54876   argp2 = (Dali::Image *)jarg2;
54877   if (!argp2) {
54878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54879     return ;
54880   }
54881   arg2 = *argp2;
54882   {
54883     try {
54884       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54885     } catch (std::out_of_range& e) {
54886       {
54887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54888       };
54889     } catch (std::exception& e) {
54890       {
54891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (Dali::DaliException e) {
54894       {
54895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54896       };
54897     } catch (...) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54900       };
54901     }
54902   }
54903
54904 }
54905
54906
54907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54908   void * jresult ;
54909   Dali::Signal< void (Dali::Image) > *result = 0 ;
54910
54911   {
54912     try {
54913       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (Dali::DaliException e) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54925       };
54926     } catch (...) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54929       };
54930     }
54931   }
54932
54933   jresult = (void *)result;
54934   return jresult;
54935 }
54936
54937
54938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54939   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54940
54941   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54942   {
54943     try {
54944       delete arg1;
54945     } catch (std::out_of_range& e) {
54946       {
54947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54948       };
54949     } catch (std::exception& e) {
54950       {
54951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (Dali::DaliException e) {
54954       {
54955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54956       };
54957     } catch (...) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54960       };
54961     }
54962   }
54963
54964 }
54965
54966
54967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54968   void * jresult ;
54969   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54970
54971   {
54972     try {
54973       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54974     } catch (std::out_of_range& e) {
54975       {
54976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54977       };
54978     } catch (std::exception& e) {
54979       {
54980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (Dali::DaliException e) {
54983       {
54984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54985       };
54986     } catch (...) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54989       };
54990     }
54991   }
54992
54993   jresult = (void *)result;
54994   return jresult;
54995 }
54996
54997
54998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54999   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55000
55001   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55002   {
55003     try {
55004       delete arg1;
55005     } catch (std::out_of_range& e) {
55006       {
55007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (std::exception& e) {
55010       {
55011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (Dali::DaliException e) {
55014       {
55015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55016       };
55017     } catch (...) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55020       };
55021     }
55022   }
55023
55024 }
55025
55026
55027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55028   unsigned int jresult ;
55029   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55030   bool result;
55031
55032   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55033   {
55034     try {
55035       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);
55036     } catch (std::out_of_range& e) {
55037       {
55038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55039       };
55040     } catch (std::exception& e) {
55041       {
55042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55043       };
55044     } catch (Dali::DaliException e) {
55045       {
55046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55047       };
55048     } catch (...) {
55049       {
55050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55051       };
55052     }
55053   }
55054
55055   jresult = result;
55056   return jresult;
55057 }
55058
55059
55060 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55061   unsigned long jresult ;
55062   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55063   std::size_t result;
55064
55065   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55066   {
55067     try {
55068       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);
55069     } catch (std::out_of_range& e) {
55070       {
55071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55072       };
55073     } catch (std::exception& e) {
55074       {
55075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (Dali::DaliException e) {
55078       {
55079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55080       };
55081     } catch (...) {
55082       {
55083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55084       };
55085     }
55086   }
55087
55088   jresult = (unsigned long)result;
55089   return jresult;
55090 }
55091
55092
55093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55094   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55095   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55096
55097   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55098   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55099   {
55100     try {
55101       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55102     } catch (std::out_of_range& e) {
55103       {
55104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55105       };
55106     } catch (std::exception& e) {
55107       {
55108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55109       };
55110     } catch (Dali::DaliException e) {
55111       {
55112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55113       };
55114     } catch (...) {
55115       {
55116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55117       };
55118     }
55119   }
55120
55121 }
55122
55123
55124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55125   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55126   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55127
55128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55129   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55130   {
55131     try {
55132       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55133     } catch (std::out_of_range& e) {
55134       {
55135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55136       };
55137     } catch (std::exception& e) {
55138       {
55139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55140       };
55141     } catch (Dali::DaliException e) {
55142       {
55143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55144       };
55145     } catch (...) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55148       };
55149     }
55150   }
55151
55152 }
55153
55154
55155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55156   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55157   Dali::Actor arg2 ;
55158   Dali::LongPressGesture *arg3 = 0 ;
55159   Dali::Actor *argp2 ;
55160
55161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55162   argp2 = (Dali::Actor *)jarg2;
55163   if (!argp2) {
55164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55165     return ;
55166   }
55167   arg2 = *argp2;
55168   arg3 = (Dali::LongPressGesture *)jarg3;
55169   if (!arg3) {
55170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55171     return ;
55172   }
55173   {
55174     try {
55175       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55176     } catch (std::out_of_range& e) {
55177       {
55178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55179       };
55180     } catch (std::exception& e) {
55181       {
55182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55183       };
55184     } catch (Dali::DaliException e) {
55185       {
55186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55187       };
55188     } catch (...) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55191       };
55192     }
55193   }
55194
55195 }
55196
55197
55198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55199   void * jresult ;
55200   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55201
55202   {
55203     try {
55204       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55205     } catch (std::out_of_range& e) {
55206       {
55207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55208       };
55209     } catch (std::exception& e) {
55210       {
55211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55212       };
55213     } catch (Dali::DaliException e) {
55214       {
55215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55216       };
55217     } catch (...) {
55218       {
55219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55220       };
55221     }
55222   }
55223
55224   jresult = (void *)result;
55225   return jresult;
55226 }
55227
55228
55229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55230   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55231
55232   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55233   {
55234     try {
55235       delete arg1;
55236     } catch (std::out_of_range& e) {
55237       {
55238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55239       };
55240     } catch (std::exception& e) {
55241       {
55242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55243       };
55244     } catch (Dali::DaliException e) {
55245       {
55246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55247       };
55248     } catch (...) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55251       };
55252     }
55253   }
55254
55255 }
55256
55257
55258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55259   unsigned int jresult ;
55260   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55261   bool result;
55262
55263   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55264   {
55265     try {
55266       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);
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (Dali::DaliException e) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55282       };
55283     }
55284   }
55285
55286   jresult = result;
55287   return jresult;
55288 }
55289
55290
55291 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55292   unsigned long jresult ;
55293   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55294   std::size_t result;
55295
55296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55297   {
55298     try {
55299       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);
55300     } catch (std::out_of_range& e) {
55301       {
55302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (std::exception& e) {
55305       {
55306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (Dali::DaliException e) {
55309       {
55310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55311       };
55312     } catch (...) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55315       };
55316     }
55317   }
55318
55319   jresult = (unsigned long)result;
55320   return jresult;
55321 }
55322
55323
55324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55325   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55326   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55327
55328   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55329   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55330   {
55331     try {
55332       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55333     } catch (std::out_of_range& e) {
55334       {
55335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55336       };
55337     } catch (std::exception& e) {
55338       {
55339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55340       };
55341     } catch (Dali::DaliException e) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55344       };
55345     } catch (...) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55348       };
55349     }
55350   }
55351
55352 }
55353
55354
55355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55356   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55357   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55358
55359   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55360   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55361   {
55362     try {
55363       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55364     } catch (std::out_of_range& e) {
55365       {
55366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55367       };
55368     } catch (std::exception& e) {
55369       {
55370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55371       };
55372     } catch (Dali::DaliException e) {
55373       {
55374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55375       };
55376     } catch (...) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55379       };
55380     }
55381   }
55382
55383 }
55384
55385
55386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55387   unsigned int jresult ;
55388   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55389   Dali::Actor arg2 ;
55390   Dali::TouchData *arg3 = 0 ;
55391   Dali::Actor *argp2 ;
55392   bool result;
55393
55394   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55395   argp2 = (Dali::Actor *)jarg2;
55396   if (!argp2) {
55397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55398     return 0;
55399   }
55400   arg2 = *argp2;
55401   arg3 = (Dali::TouchData *)jarg3;
55402   if (!arg3) {
55403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55404     return 0;
55405   }
55406   {
55407     try {
55408       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55409     } catch (std::out_of_range& e) {
55410       {
55411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55412       };
55413     } catch (std::exception& e) {
55414       {
55415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (Dali::DaliException e) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55420       };
55421     } catch (...) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55424       };
55425     }
55426   }
55427
55428   jresult = result;
55429   return jresult;
55430 }
55431
55432
55433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55434   void * jresult ;
55435   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55436
55437   {
55438     try {
55439       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55440     } catch (std::out_of_range& e) {
55441       {
55442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (std::exception& e) {
55445       {
55446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (Dali::DaliException e) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55451       };
55452     } catch (...) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55455       };
55456     }
55457   }
55458
55459   jresult = (void *)result;
55460   return jresult;
55461 }
55462
55463
55464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55465   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55466
55467   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55468   {
55469     try {
55470       delete arg1;
55471     } catch (std::out_of_range& e) {
55472       {
55473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55474       };
55475     } catch (std::exception& e) {
55476       {
55477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55478       };
55479     } catch (Dali::DaliException e) {
55480       {
55481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55482       };
55483     } catch (...) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55486       };
55487     }
55488   }
55489
55490 }
55491
55492
55493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55494   unsigned int jresult ;
55495   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55496   bool result;
55497
55498   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55499   {
55500     try {
55501       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);
55502     } catch (std::out_of_range& e) {
55503       {
55504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (std::exception& e) {
55507       {
55508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (Dali::DaliException e) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55517       };
55518     }
55519   }
55520
55521   jresult = result;
55522   return jresult;
55523 }
55524
55525
55526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55527   unsigned long jresult ;
55528   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55529   std::size_t result;
55530
55531   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55532   {
55533     try {
55534       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);
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55542       };
55543     } catch (Dali::DaliException e) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55546       };
55547     } catch (...) {
55548       {
55549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55550       };
55551     }
55552   }
55553
55554   jresult = (unsigned long)result;
55555   return jresult;
55556 }
55557
55558
55559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55560   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55561   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55562
55563   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55564   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55565   {
55566     try {
55567       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55568     } catch (std::out_of_range& e) {
55569       {
55570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55571       };
55572     } catch (std::exception& e) {
55573       {
55574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55575       };
55576     } catch (Dali::DaliException e) {
55577       {
55578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55579       };
55580     } catch (...) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55583       };
55584     }
55585   }
55586
55587 }
55588
55589
55590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55591   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55592   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55593
55594   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55595   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55596   {
55597     try {
55598       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55599     } catch (std::out_of_range& e) {
55600       {
55601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55602       };
55603     } catch (std::exception& e) {
55604       {
55605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55606       };
55607     } catch (Dali::DaliException e) {
55608       {
55609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55610       };
55611     } catch (...) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55614       };
55615     }
55616   }
55617
55618 }
55619
55620
55621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55622   unsigned int jresult ;
55623   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55624   Dali::Actor arg2 ;
55625   Dali::HoverEvent *arg3 = 0 ;
55626   Dali::Actor *argp2 ;
55627   bool result;
55628
55629   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55630   argp2 = (Dali::Actor *)jarg2;
55631   if (!argp2) {
55632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55633     return 0;
55634   }
55635   arg2 = *argp2;
55636   arg3 = (Dali::HoverEvent *)jarg3;
55637   if (!arg3) {
55638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55639     return 0;
55640   }
55641   {
55642     try {
55643       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55644     } catch (std::out_of_range& e) {
55645       {
55646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55647       };
55648     } catch (std::exception& e) {
55649       {
55650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (Dali::DaliException e) {
55653       {
55654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55655       };
55656     } catch (...) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55659       };
55660     }
55661   }
55662
55663   jresult = result;
55664   return jresult;
55665 }
55666
55667
55668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55669   void * jresult ;
55670   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55671
55672   {
55673     try {
55674       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55675     } catch (std::out_of_range& e) {
55676       {
55677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (std::exception& e) {
55680       {
55681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (Dali::DaliException e) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55686       };
55687     } catch (...) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55690       };
55691     }
55692   }
55693
55694   jresult = (void *)result;
55695   return jresult;
55696 }
55697
55698
55699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55700   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55701
55702   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55703   {
55704     try {
55705       delete arg1;
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55713       };
55714     } catch (Dali::DaliException e) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55717       };
55718     } catch (...) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55721       };
55722     }
55723   }
55724
55725 }
55726
55727
55728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55729   unsigned int jresult ;
55730   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55731   bool result;
55732
55733   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55734   {
55735     try {
55736       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);
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (Dali::DaliException e) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755
55756   jresult = result;
55757   return jresult;
55758 }
55759
55760
55761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55762   unsigned long jresult ;
55763   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55764   std::size_t result;
55765
55766   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55767   {
55768     try {
55769       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);
55770     } catch (std::out_of_range& e) {
55771       {
55772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (std::exception& e) {
55775       {
55776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (Dali::DaliException e) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55781       };
55782     } catch (...) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55785       };
55786     }
55787   }
55788
55789   jresult = (unsigned long)result;
55790   return jresult;
55791 }
55792
55793
55794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55795   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55796   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55797
55798   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55799   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55800   {
55801     try {
55802       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55803     } catch (std::out_of_range& e) {
55804       {
55805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55806       };
55807     } catch (std::exception& e) {
55808       {
55809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55810       };
55811     } catch (Dali::DaliException e) {
55812       {
55813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55814       };
55815     } catch (...) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55818       };
55819     }
55820   }
55821
55822 }
55823
55824
55825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55826   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55827   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55828
55829   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55830   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55831   {
55832     try {
55833       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55834     } catch (std::out_of_range& e) {
55835       {
55836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55837       };
55838     } catch (std::exception& e) {
55839       {
55840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (Dali::DaliException e) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55845       };
55846     } catch (...) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55849       };
55850     }
55851   }
55852
55853 }
55854
55855
55856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55857   unsigned int jresult ;
55858   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55859   Dali::Actor arg2 ;
55860   Dali::WheelEvent *arg3 = 0 ;
55861   Dali::Actor *argp2 ;
55862   bool result;
55863
55864   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55865   argp2 = (Dali::Actor *)jarg2;
55866   if (!argp2) {
55867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55868     return 0;
55869   }
55870   arg2 = *argp2;
55871   arg3 = (Dali::WheelEvent *)jarg3;
55872   if (!arg3) {
55873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55874     return 0;
55875   }
55876   {
55877     try {
55878       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55879     } catch (std::out_of_range& e) {
55880       {
55881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55882       };
55883     } catch (std::exception& e) {
55884       {
55885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (Dali::DaliException e) {
55888       {
55889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55890       };
55891     } catch (...) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55894       };
55895     }
55896   }
55897
55898   jresult = result;
55899   return jresult;
55900 }
55901
55902
55903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55904   void * jresult ;
55905   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55906
55907   {
55908     try {
55909       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55910     } catch (std::out_of_range& e) {
55911       {
55912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55913       };
55914     } catch (std::exception& e) {
55915       {
55916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55917       };
55918     } catch (Dali::DaliException e) {
55919       {
55920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55921       };
55922     } catch (...) {
55923       {
55924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55925       };
55926     }
55927   }
55928
55929   jresult = (void *)result;
55930   return jresult;
55931 }
55932
55933
55934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55935   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55936
55937   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55938   {
55939     try {
55940       delete arg1;
55941     } catch (std::out_of_range& e) {
55942       {
55943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55944       };
55945     } catch (std::exception& e) {
55946       {
55947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55948       };
55949     } catch (Dali::DaliException e) {
55950       {
55951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55952       };
55953     } catch (...) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55956       };
55957     }
55958   }
55959
55960 }
55961
55962
55963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55964   unsigned int jresult ;
55965   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55966   bool result;
55967
55968   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55969   {
55970     try {
55971       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55972     } catch (std::out_of_range& e) {
55973       {
55974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55975       };
55976     } catch (std::exception& e) {
55977       {
55978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (Dali::DaliException e) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55983       };
55984     } catch (...) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55987       };
55988     }
55989   }
55990
55991   jresult = result;
55992   return jresult;
55993 }
55994
55995
55996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55997   unsigned long jresult ;
55998   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55999   std::size_t result;
56000
56001   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56002   {
56003     try {
56004       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56005     } catch (std::out_of_range& e) {
56006       {
56007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (std::exception& e) {
56010       {
56011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (Dali::DaliException e) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56016       };
56017     } catch (...) {
56018       {
56019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56020       };
56021     }
56022   }
56023
56024   jresult = (unsigned long)result;
56025   return jresult;
56026 }
56027
56028
56029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56030   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56031   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56032
56033   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56034   arg2 = (void (*)(Dali::Actor))jarg2;
56035   {
56036     try {
56037       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56045       };
56046     } catch (Dali::DaliException e) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56049       };
56050     } catch (...) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56053       };
56054     }
56055   }
56056
56057 }
56058
56059
56060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56061   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56062   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56063
56064   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56065   arg2 = (void (*)(Dali::Actor))jarg2;
56066   {
56067     try {
56068       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56069     } catch (std::out_of_range& e) {
56070       {
56071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56072       };
56073     } catch (std::exception& e) {
56074       {
56075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56076       };
56077     } catch (Dali::DaliException e) {
56078       {
56079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56080       };
56081     } catch (...) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56084       };
56085     }
56086   }
56087
56088 }
56089
56090
56091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56092   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56093   Dali::Actor arg2 ;
56094   Dali::Actor *argp2 ;
56095
56096   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56097   argp2 = (Dali::Actor *)jarg2;
56098   if (!argp2) {
56099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56100     return ;
56101   }
56102   arg2 = *argp2;
56103   {
56104     try {
56105       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (Dali::DaliException e) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56121       };
56122     }
56123   }
56124
56125 }
56126
56127
56128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56129   void * jresult ;
56130   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56131
56132   {
56133     try {
56134       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56135     } catch (std::out_of_range& e) {
56136       {
56137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56138       };
56139     } catch (std::exception& e) {
56140       {
56141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (Dali::DaliException e) {
56144       {
56145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56146       };
56147     } catch (...) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56150       };
56151     }
56152   }
56153
56154   jresult = (void *)result;
56155   return jresult;
56156 }
56157
56158
56159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56160   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56161
56162   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56163   {
56164     try {
56165       delete arg1;
56166     } catch (std::out_of_range& e) {
56167       {
56168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56169       };
56170     } catch (std::exception& e) {
56171       {
56172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56173       };
56174     } catch (Dali::DaliException e) {
56175       {
56176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56177       };
56178     } catch (...) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56181       };
56182     }
56183   }
56184
56185 }
56186
56187
56188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56189   unsigned int jresult ;
56190   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56191   bool result;
56192
56193   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56194   {
56195     try {
56196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56197     } catch (std::out_of_range& e) {
56198       {
56199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56200       };
56201     } catch (std::exception& e) {
56202       {
56203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (Dali::DaliException e) {
56206       {
56207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56208       };
56209     } catch (...) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56212       };
56213     }
56214   }
56215
56216   jresult = result;
56217   return jresult;
56218 }
56219
56220
56221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56222   unsigned long jresult ;
56223   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56224   std::size_t result;
56225
56226   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56227   {
56228     try {
56229       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56230     } catch (std::out_of_range& e) {
56231       {
56232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56233       };
56234     } catch (std::exception& e) {
56235       {
56236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (Dali::DaliException e) {
56239       {
56240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248
56249   jresult = (unsigned long)result;
56250   return jresult;
56251 }
56252
56253
56254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56255   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56256   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56257
56258   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56259   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56260   {
56261     try {
56262       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (Dali::DaliException e) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56274       };
56275     } catch (...) {
56276       {
56277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56278       };
56279     }
56280   }
56281
56282 }
56283
56284
56285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56286   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56287   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56288
56289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56290   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56291   {
56292     try {
56293       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56294     } catch (std::out_of_range& e) {
56295       {
56296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56297       };
56298     } catch (std::exception& e) {
56299       {
56300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (Dali::DaliException e) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56305       };
56306     } catch (...) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56309       };
56310     }
56311   }
56312
56313 }
56314
56315
56316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56317   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56318   Dali::KeyEvent *arg2 = 0 ;
56319
56320   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56321   arg2 = (Dali::KeyEvent *)jarg2;
56322   if (!arg2) {
56323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56324     return ;
56325   }
56326   {
56327     try {
56328       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56329     } catch (std::out_of_range& e) {
56330       {
56331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56332       };
56333     } catch (std::exception& e) {
56334       {
56335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (Dali::DaliException e) {
56338       {
56339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56340       };
56341     } catch (...) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56344       };
56345     }
56346   }
56347
56348 }
56349
56350
56351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56352   void * jresult ;
56353   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56354
56355   {
56356     try {
56357       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56358     } catch (std::out_of_range& e) {
56359       {
56360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56361       };
56362     } catch (std::exception& e) {
56363       {
56364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (Dali::DaliException e) {
56367       {
56368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56369       };
56370     } catch (...) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56373       };
56374     }
56375   }
56376
56377   jresult = (void *)result;
56378   return jresult;
56379 }
56380
56381
56382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56383   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56384
56385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56386   {
56387     try {
56388       delete arg1;
56389     } catch (std::out_of_range& e) {
56390       {
56391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56392       };
56393     } catch (std::exception& e) {
56394       {
56395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (Dali::DaliException e) {
56398       {
56399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56404       };
56405     }
56406   }
56407
56408 }
56409
56410
56411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56412   unsigned int jresult ;
56413   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56414   bool result;
56415
56416   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56417   {
56418     try {
56419       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56420     } catch (std::out_of_range& e) {
56421       {
56422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56423       };
56424     } catch (std::exception& e) {
56425       {
56426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (Dali::DaliException e) {
56429       {
56430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56431       };
56432     } catch (...) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56435       };
56436     }
56437   }
56438
56439   jresult = result;
56440   return jresult;
56441 }
56442
56443
56444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56445   unsigned long jresult ;
56446   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56447   std::size_t result;
56448
56449   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56450   {
56451     try {
56452       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (Dali::DaliException e) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56464       };
56465     } catch (...) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56468       };
56469     }
56470   }
56471
56472   jresult = (unsigned long)result;
56473   return jresult;
56474 }
56475
56476
56477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56478   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56479   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56480
56481   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56482   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56483   {
56484     try {
56485       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56486     } catch (std::out_of_range& e) {
56487       {
56488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56489       };
56490     } catch (std::exception& e) {
56491       {
56492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56493       };
56494     } catch (Dali::DaliException e) {
56495       {
56496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56501       };
56502     }
56503   }
56504
56505 }
56506
56507
56508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56509   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56510   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56511
56512   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56513   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56514   {
56515     try {
56516       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56517     } catch (std::out_of_range& e) {
56518       {
56519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56520       };
56521     } catch (std::exception& e) {
56522       {
56523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56524       };
56525     } catch (Dali::DaliException e) {
56526       {
56527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56532       };
56533     }
56534   }
56535
56536 }
56537
56538
56539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56540   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56541   Dali::TouchData *arg2 = 0 ;
56542
56543   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56544   arg2 = (Dali::TouchData *)jarg2;
56545   if (!arg2) {
56546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56547     return ;
56548   }
56549   {
56550     try {
56551       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56552     } catch (std::out_of_range& e) {
56553       {
56554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56555       };
56556     } catch (std::exception& e) {
56557       {
56558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56559       };
56560     } catch (Dali::DaliException e) {
56561       {
56562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56563       };
56564     } catch (...) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56567       };
56568     }
56569   }
56570
56571 }
56572
56573
56574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56575   void * jresult ;
56576   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56577
56578   {
56579     try {
56580       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56581     } catch (std::out_of_range& e) {
56582       {
56583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56584       };
56585     } catch (std::exception& e) {
56586       {
56587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (Dali::DaliException e) {
56590       {
56591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56592       };
56593     } catch (...) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56596       };
56597     }
56598   }
56599
56600   jresult = (void *)result;
56601   return jresult;
56602 }
56603
56604
56605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56606   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56607
56608   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56609   {
56610     try {
56611       delete arg1;
56612     } catch (std::out_of_range& e) {
56613       {
56614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56615       };
56616     } catch (std::exception& e) {
56617       {
56618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56619       };
56620     } catch (Dali::DaliException e) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56623       };
56624     } catch (...) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56627       };
56628     }
56629   }
56630
56631 }
56632
56633
56634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56635   unsigned int jresult ;
56636   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56637   bool result;
56638
56639   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56640   {
56641     try {
56642       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56643     } catch (std::out_of_range& e) {
56644       {
56645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56646       };
56647     } catch (std::exception& e) {
56648       {
56649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (Dali::DaliException e) {
56652       {
56653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56654       };
56655     } catch (...) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56658       };
56659     }
56660   }
56661
56662   jresult = result;
56663   return jresult;
56664 }
56665
56666
56667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56668   unsigned long jresult ;
56669   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56670   std::size_t result;
56671
56672   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56673   {
56674     try {
56675       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56676     } catch (std::out_of_range& e) {
56677       {
56678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56679       };
56680     } catch (std::exception& e) {
56681       {
56682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (Dali::DaliException e) {
56685       {
56686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56687       };
56688     } catch (...) {
56689       {
56690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56691       };
56692     }
56693   }
56694
56695   jresult = (unsigned long)result;
56696   return jresult;
56697 }
56698
56699
56700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56701   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56702   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56703
56704   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56705   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56706   {
56707     try {
56708       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56709     } catch (std::out_of_range& e) {
56710       {
56711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56712       };
56713     } catch (std::exception& e) {
56714       {
56715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56716       };
56717     } catch (Dali::DaliException e) {
56718       {
56719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56720       };
56721     } catch (...) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56724       };
56725     }
56726   }
56727
56728 }
56729
56730
56731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56732   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56733   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56734
56735   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56736   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56737   {
56738     try {
56739       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56740     } catch (std::out_of_range& e) {
56741       {
56742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56743       };
56744     } catch (std::exception& e) {
56745       {
56746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56747       };
56748     } catch (Dali::DaliException e) {
56749       {
56750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56751       };
56752     } catch (...) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56755       };
56756     }
56757   }
56758
56759 }
56760
56761
56762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56763   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56764   Dali::WheelEvent *arg2 = 0 ;
56765
56766   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56767   arg2 = (Dali::WheelEvent *)jarg2;
56768   if (!arg2) {
56769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56770     return ;
56771   }
56772   {
56773     try {
56774       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (Dali::DaliException e) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56786       };
56787     } catch (...) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56790       };
56791     }
56792   }
56793
56794 }
56795
56796
56797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56798   void * jresult ;
56799   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56800
56801   {
56802     try {
56803       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56804     } catch (std::out_of_range& e) {
56805       {
56806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56807       };
56808     } catch (std::exception& e) {
56809       {
56810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56811       };
56812     } catch (Dali::DaliException e) {
56813       {
56814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56815       };
56816     } catch (...) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56819       };
56820     }
56821   }
56822
56823   jresult = (void *)result;
56824   return jresult;
56825 }
56826
56827
56828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56829   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56830
56831   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56832   {
56833     try {
56834       delete arg1;
56835     } catch (std::out_of_range& e) {
56836       {
56837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56838       };
56839     } catch (std::exception& e) {
56840       {
56841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56842       };
56843     } catch (Dali::DaliException e) {
56844       {
56845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56846       };
56847     } catch (...) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56850       };
56851     }
56852   }
56853
56854 }
56855
56856
56857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56858   void * jresult ;
56859   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56860
56861   {
56862     try {
56863       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56864     } catch (std::out_of_range& e) {
56865       {
56866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56867       };
56868     } catch (std::exception& e) {
56869       {
56870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (Dali::DaliException e) {
56873       {
56874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56875       };
56876     } catch (...) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56879       };
56880     }
56881   }
56882
56883   jresult = (void *)result;
56884   return jresult;
56885 }
56886
56887
56888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56889   void * jresult ;
56890   Dali::Radian arg1 ;
56891   Dali::Radian arg2 ;
56892   Dali::Radian *argp1 ;
56893   Dali::Radian *argp2 ;
56894   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56895
56896   argp1 = (Dali::Radian *)jarg1;
56897   if (!argp1) {
56898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56899     return 0;
56900   }
56901   arg1 = *argp1;
56902   argp2 = (Dali::Radian *)jarg2;
56903   if (!argp2) {
56904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56905     return 0;
56906   }
56907   arg2 = *argp2;
56908   {
56909     try {
56910       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56911     } catch (std::out_of_range& e) {
56912       {
56913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (std::exception& e) {
56916       {
56917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (Dali::DaliException e) {
56920       {
56921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56922       };
56923     } catch (...) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56926       };
56927     }
56928   }
56929
56930   jresult = (void *)result;
56931   return jresult;
56932 }
56933
56934
56935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56936   void * jresult ;
56937   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56938   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56939
56940   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56941   if (!arg1) {
56942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56943     return 0;
56944   }
56945   {
56946     try {
56947       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56948     } catch (std::out_of_range& e) {
56949       {
56950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56951       };
56952     } catch (std::exception& e) {
56953       {
56954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (Dali::DaliException e) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56963       };
56964     }
56965   }
56966
56967   jresult = (void *)result;
56968   return jresult;
56969 }
56970
56971
56972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56973   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56974   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56975
56976   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56977   arg2 = (Dali::Radian *)jarg2;
56978   if (arg1) (arg1)->first = *arg2;
56979 }
56980
56981
56982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56983   void * jresult ;
56984   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56985   Dali::Radian *result = 0 ;
56986
56987   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56988   result = (Dali::Radian *)& ((arg1)->first);
56989   jresult = (void *)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56995   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56996   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56997
56998   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56999   arg2 = (Dali::Radian *)jarg2;
57000   if (arg1) (arg1)->second = *arg2;
57001 }
57002
57003
57004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57005   void * jresult ;
57006   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57007   Dali::Radian *result = 0 ;
57008
57009   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57010   result = (Dali::Radian *)& ((arg1)->second);
57011   jresult = (void *)result;
57012   return jresult;
57013 }
57014
57015
57016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57017   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57018
57019   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57020   {
57021     try {
57022       delete arg1;
57023     } catch (std::out_of_range& e) {
57024       {
57025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57026       };
57027     } catch (std::exception& e) {
57028       {
57029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (Dali::DaliException e) {
57032       {
57033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57038       };
57039     }
57040   }
57041
57042 }
57043
57044
57045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57046   unsigned int jresult ;
57047   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57048   bool result;
57049
57050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57051   {
57052     try {
57053       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);
57054     } catch (std::out_of_range& e) {
57055       {
57056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57057       };
57058     } catch (std::exception& e) {
57059       {
57060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (Dali::DaliException e) {
57063       {
57064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57065       };
57066     } catch (...) {
57067       {
57068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57069       };
57070     }
57071   }
57072
57073   jresult = result;
57074   return jresult;
57075 }
57076
57077
57078 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57079   unsigned long jresult ;
57080   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57081   std::size_t result;
57082
57083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57084   {
57085     try {
57086       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);
57087     } catch (std::out_of_range& e) {
57088       {
57089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57090       };
57091     } catch (std::exception& e) {
57092       {
57093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57094       };
57095     } catch (Dali::DaliException e) {
57096       {
57097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57098       };
57099     } catch (...) {
57100       {
57101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57102       };
57103     }
57104   }
57105
57106   jresult = (unsigned long)result;
57107   return jresult;
57108 }
57109
57110
57111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57112   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57113   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57114
57115   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57116   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57117   {
57118     try {
57119       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57120     } catch (std::out_of_range& e) {
57121       {
57122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57123       };
57124     } catch (std::exception& e) {
57125       {
57126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (Dali::DaliException e) {
57129       {
57130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57131       };
57132     } catch (...) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57135       };
57136     }
57137   }
57138
57139 }
57140
57141
57142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57143   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57144   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57145
57146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57147   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57148   {
57149     try {
57150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57151     } catch (std::out_of_range& e) {
57152       {
57153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57154       };
57155     } catch (std::exception& e) {
57156       {
57157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57158       };
57159     } catch (Dali::DaliException e) {
57160       {
57161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57162       };
57163     } catch (...) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57166       };
57167     }
57168   }
57169
57170 }
57171
57172
57173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57174   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57175   Dali::Actor arg2 ;
57176   Dali::PanGesture *arg3 = 0 ;
57177   Dali::Actor *argp2 ;
57178
57179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57180   argp2 = (Dali::Actor *)jarg2;
57181   if (!argp2) {
57182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57183     return ;
57184   }
57185   arg2 = *argp2;
57186   arg3 = (Dali::PanGesture *)jarg3;
57187   if (!arg3) {
57188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57189     return ;
57190   }
57191   {
57192     try {
57193       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57194     } catch (std::out_of_range& e) {
57195       {
57196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57197       };
57198     } catch (std::exception& e) {
57199       {
57200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57201       };
57202     } catch (Dali::DaliException e) {
57203       {
57204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57205       };
57206     } catch (...) {
57207       {
57208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57209       };
57210     }
57211   }
57212
57213 }
57214
57215
57216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57217   void * jresult ;
57218   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57219
57220   {
57221     try {
57222       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57223     } catch (std::out_of_range& e) {
57224       {
57225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (std::exception& e) {
57228       {
57229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (Dali::DaliException e) {
57232       {
57233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57234       };
57235     } catch (...) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57238       };
57239     }
57240   }
57241
57242   jresult = (void *)result;
57243   return jresult;
57244 }
57245
57246
57247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57248   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57249
57250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57251   {
57252     try {
57253       delete arg1;
57254     } catch (std::out_of_range& e) {
57255       {
57256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57257       };
57258     } catch (std::exception& e) {
57259       {
57260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (Dali::DaliException e) {
57263       {
57264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57265       };
57266     } catch (...) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57269       };
57270     }
57271   }
57272
57273 }
57274
57275
57276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57277   unsigned int jresult ;
57278   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57279   bool result;
57280
57281   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57282   {
57283     try {
57284       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);
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (Dali::DaliException e) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57296       };
57297     } catch (...) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57300       };
57301     }
57302   }
57303
57304   jresult = result;
57305   return jresult;
57306 }
57307
57308
57309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57310   unsigned long jresult ;
57311   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57312   std::size_t result;
57313
57314   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57315   {
57316     try {
57317       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);
57318     } catch (std::out_of_range& e) {
57319       {
57320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57321       };
57322     } catch (std::exception& e) {
57323       {
57324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57325       };
57326     } catch (Dali::DaliException e) {
57327       {
57328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57329       };
57330     } catch (...) {
57331       {
57332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57333       };
57334     }
57335   }
57336
57337   jresult = (unsigned long)result;
57338   return jresult;
57339 }
57340
57341
57342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57343   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57344   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57345
57346   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57347   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57348   {
57349     try {
57350       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57351     } catch (std::out_of_range& e) {
57352       {
57353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57354       };
57355     } catch (std::exception& e) {
57356       {
57357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57358       };
57359     } catch (Dali::DaliException e) {
57360       {
57361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57362       };
57363     } catch (...) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57366       };
57367     }
57368   }
57369
57370 }
57371
57372
57373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57374   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57375   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57376
57377   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57378   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57379   {
57380     try {
57381       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57382     } catch (std::out_of_range& e) {
57383       {
57384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57385       };
57386     } catch (std::exception& e) {
57387       {
57388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57389       };
57390     } catch (Dali::DaliException e) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57393       };
57394     } catch (...) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57397       };
57398     }
57399   }
57400
57401 }
57402
57403
57404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57405   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57406   Dali::Actor arg2 ;
57407   Dali::PinchGesture *arg3 = 0 ;
57408   Dali::Actor *argp2 ;
57409
57410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57411   argp2 = (Dali::Actor *)jarg2;
57412   if (!argp2) {
57413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57414     return ;
57415   }
57416   arg2 = *argp2;
57417   arg3 = (Dali::PinchGesture *)jarg3;
57418   if (!arg3) {
57419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57420     return ;
57421   }
57422   {
57423     try {
57424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57425     } catch (std::out_of_range& e) {
57426       {
57427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57428       };
57429     } catch (std::exception& e) {
57430       {
57431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (Dali::DaliException e) {
57434       {
57435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57436       };
57437     } catch (...) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57440       };
57441     }
57442   }
57443
57444 }
57445
57446
57447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57448   void * jresult ;
57449   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57450
57451   {
57452     try {
57453       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (Dali::DaliException e) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57465       };
57466     } catch (...) {
57467       {
57468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57469       };
57470     }
57471   }
57472
57473   jresult = (void *)result;
57474   return jresult;
57475 }
57476
57477
57478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57479   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57480
57481   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57482   {
57483     try {
57484       delete arg1;
57485     } catch (std::out_of_range& e) {
57486       {
57487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57488       };
57489     } catch (std::exception& e) {
57490       {
57491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (Dali::DaliException e) {
57494       {
57495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57496       };
57497     } catch (...) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57500       };
57501     }
57502   }
57503
57504 }
57505
57506
57507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57508   unsigned int jresult ;
57509   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57510   bool result;
57511
57512   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57513   {
57514     try {
57515       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);
57516     } catch (std::out_of_range& e) {
57517       {
57518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57519       };
57520     } catch (std::exception& e) {
57521       {
57522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (Dali::DaliException e) {
57525       {
57526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534
57535   jresult = result;
57536   return jresult;
57537 }
57538
57539
57540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57541   unsigned long jresult ;
57542   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57543   std::size_t result;
57544
57545   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57546   {
57547     try {
57548       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);
57549     } catch (std::out_of_range& e) {
57550       {
57551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57552       };
57553     } catch (std::exception& e) {
57554       {
57555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (Dali::DaliException e) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57560       };
57561     } catch (...) {
57562       {
57563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57564       };
57565     }
57566   }
57567
57568   jresult = (unsigned long)result;
57569   return jresult;
57570 }
57571
57572
57573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57574   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57575   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57576
57577   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57578   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57579   {
57580     try {
57581       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57582     } catch (std::out_of_range& e) {
57583       {
57584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57585       };
57586     } catch (std::exception& e) {
57587       {
57588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57589       };
57590     } catch (Dali::DaliException e) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57593       };
57594     } catch (...) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57597       };
57598     }
57599   }
57600
57601 }
57602
57603
57604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57605   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57606   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57607
57608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57609   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57610   {
57611     try {
57612       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57613     } catch (std::out_of_range& e) {
57614       {
57615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57616       };
57617     } catch (std::exception& e) {
57618       {
57619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57620       };
57621     } catch (Dali::DaliException e) {
57622       {
57623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57624       };
57625     } catch (...) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57628       };
57629     }
57630   }
57631
57632 }
57633
57634
57635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57636   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57637   Dali::Actor arg2 ;
57638   Dali::TapGesture *arg3 = 0 ;
57639   Dali::Actor *argp2 ;
57640
57641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57642   argp2 = (Dali::Actor *)jarg2;
57643   if (!argp2) {
57644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57645     return ;
57646   }
57647   arg2 = *argp2;
57648   arg3 = (Dali::TapGesture *)jarg3;
57649   if (!arg3) {
57650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57651     return ;
57652   }
57653   {
57654     try {
57655       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57656     } catch (std::out_of_range& e) {
57657       {
57658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57659       };
57660     } catch (std::exception& e) {
57661       {
57662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57663       };
57664     } catch (Dali::DaliException e) {
57665       {
57666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57667       };
57668     } catch (...) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57671       };
57672     }
57673   }
57674
57675 }
57676
57677
57678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57679   void * jresult ;
57680   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57681
57682   {
57683     try {
57684       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57685     } catch (std::out_of_range& e) {
57686       {
57687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57688       };
57689     } catch (std::exception& e) {
57690       {
57691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (Dali::DaliException e) {
57694       {
57695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57696       };
57697     } catch (...) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57700       };
57701     }
57702   }
57703
57704   jresult = (void *)result;
57705   return jresult;
57706 }
57707
57708
57709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57710   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57711
57712   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57713   {
57714     try {
57715       delete arg1;
57716     } catch (std::out_of_range& e) {
57717       {
57718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57719       };
57720     } catch (std::exception& e) {
57721       {
57722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57723       };
57724     } catch (Dali::DaliException e) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57727       };
57728     } catch (...) {
57729       {
57730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57731       };
57732     }
57733   }
57734
57735 }
57736
57737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57738   unsigned int jresult ;
57739   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57740   bool result;
57741
57742   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57743   {
57744     try {
57745       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (Dali::DaliException e) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57757       };
57758     } catch (...) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57761       };
57762     }
57763   }
57764
57765   jresult = result;
57766   return jresult;
57767 }
57768
57769
57770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57771   unsigned long jresult ;
57772   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57773   std::size_t result;
57774
57775   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57776   {
57777     try {
57778       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57779     } catch (std::out_of_range& e) {
57780       {
57781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57782       };
57783     } catch (std::exception& e) {
57784       {
57785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (Dali::DaliException e) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57790       };
57791     } catch (...) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57794       };
57795     }
57796   }
57797
57798   jresult = (unsigned long)result;
57799   return jresult;
57800 }
57801
57802
57803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57804   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57805   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57806
57807   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57808   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57809   {
57810     try {
57811       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
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
57834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57835   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57836   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57837
57838   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57839   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57840   {
57841     try {
57842       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57843     } catch (std::out_of_range& e) {
57844       {
57845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57846       };
57847     } catch (std::exception& e) {
57848       {
57849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57850       };
57851     } catch (Dali::DaliException e) {
57852       {
57853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57854       };
57855     } catch (...) {
57856       {
57857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57858       };
57859     }
57860   }
57861
57862 }
57863
57864
57865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57866   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57867   Dali::ResourceImage arg2 ;
57868   Dali::ResourceImage *argp2 ;
57869
57870   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57871   argp2 = (Dali::ResourceImage *)jarg2;
57872   if (!argp2) {
57873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57874     return ;
57875   }
57876   arg2 = *argp2;
57877   {
57878     try {
57879       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57880     } catch (std::out_of_range& e) {
57881       {
57882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57883       };
57884     } catch (std::exception& e) {
57885       {
57886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57887       };
57888     } catch (Dali::DaliException e) {
57889       {
57890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57891       };
57892     } catch (...) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57895       };
57896     }
57897   }
57898
57899 }
57900
57901
57902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57903   void * jresult ;
57904   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57905
57906   {
57907     try {
57908       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (Dali::DaliException e) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927
57928   jresult = (void *)result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57934   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57935
57936   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57937   {
57938     try {
57939       delete arg1;
57940     } catch (std::out_of_range& e) {
57941       {
57942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57943       };
57944     } catch (std::exception& e) {
57945       {
57946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57947       };
57948     } catch (Dali::DaliException e) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57951       };
57952     } catch (...) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57955       };
57956     }
57957   }
57958
57959 }
57960
57961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57962   unsigned int jresult ;
57963   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57964   bool result = false;
57965
57966   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57967   {
57968     try {
57969       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);
57970     } catch (std::out_of_range& e) {
57971       {
57972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57973       };
57974     } catch (std::exception& e) {
57975       {
57976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57979   }
57980   jresult = result;
57981   return jresult;
57982 }
57983
57984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57985   unsigned long jresult ;
57986   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57987   std::size_t result = 0;
57988
57989   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57990   {
57991     try {
57992       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);
57993     } catch (std::out_of_range& e) {
57994       {
57995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (std::exception& e) {
57998       {
57999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58002   }
58003   jresult = (unsigned long)result;
58004   return jresult;
58005 }
58006
58007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58008   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58009   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58010
58011   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58012   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58013   {
58014     try {
58015       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58016     } catch (std::out_of_range& e) {
58017       {
58018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58019       };
58020     } catch (std::exception& e) {
58021       {
58022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58023       };
58024     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58025   }
58026 }
58027
58028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58029   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58030   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58031
58032   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58033   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58034   {
58035     try {
58036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58037     } catch (std::out_of_range& e) {
58038       {
58039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58040       };
58041     } catch (std::exception& e) {
58042       {
58043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58044       };
58045     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58046   }
58047 }
58048
58049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58050   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58051   Dali::Actor arg2 ;
58052   //bool arg3 ;
58053   Dali::LayoutDirection::Type arg4 ;
58054   Dali::Actor *argp2 ;
58055
58056   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58057   argp2 = (Dali::Actor *)jarg2;
58058   if (!argp2) {
58059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58060     return ;
58061   }
58062   arg2 = *argp2;
58063   //arg3 = jarg3 ? true : false;
58064   arg4 = (Dali::LayoutDirection::Type)jarg4;
58065   {
58066     try {
58067       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58068     } catch (std::out_of_range& e) {
58069       {
58070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58071       };
58072     } catch (std::exception& e) {
58073       {
58074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58075       };
58076     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58077   }
58078 }
58079
58080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58081   void * jresult ;
58082   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58083
58084   {
58085     try {
58086       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58087     } catch (std::out_of_range& e) {
58088       {
58089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (std::exception& e) {
58092       {
58093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58096   }
58097   jresult = (void *)result;
58098   return jresult;
58099 }
58100
58101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58102   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58103
58104   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58105   {
58106     try {
58107       delete arg1;
58108     } catch (std::out_of_range& e) {
58109       {
58110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58111       };
58112     } catch (std::exception& e) {
58113       {
58114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58117   }
58118 }
58119
58120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58121   unsigned int jresult ;
58122   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58123   bool result;
58124
58125   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58126   {
58127     try {
58128       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);
58129     } catch (std::out_of_range& e) {
58130       {
58131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (std::exception& e) {
58134       {
58135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (Dali::DaliException e) {
58138       {
58139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58140       };
58141     } catch (...) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58144       };
58145     }
58146   }
58147
58148   jresult = result;
58149   return jresult;
58150 }
58151
58152
58153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58154   unsigned long jresult ;
58155   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58156   std::size_t result;
58157
58158   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58159   {
58160     try {
58161       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);
58162     } catch (std::out_of_range& e) {
58163       {
58164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58165       };
58166     } catch (std::exception& e) {
58167       {
58168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58169       };
58170     } catch (Dali::DaliException e) {
58171       {
58172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58173       };
58174     } catch (...) {
58175       {
58176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58177       };
58178     }
58179   }
58180
58181   jresult = (unsigned long)result;
58182   return jresult;
58183 }
58184
58185
58186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58187   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58188   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58189
58190   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58191   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58192   {
58193     try {
58194       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58195     } catch (std::out_of_range& e) {
58196       {
58197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58198       };
58199     } catch (std::exception& e) {
58200       {
58201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58202       };
58203     } catch (Dali::DaliException e) {
58204       {
58205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58206       };
58207     } catch (...) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58210       };
58211     }
58212   }
58213
58214 }
58215
58216
58217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58218   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58219   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58220
58221   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58222   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58223   {
58224     try {
58225       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58226     } catch (std::out_of_range& e) {
58227       {
58228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58229       };
58230     } catch (std::exception& e) {
58231       {
58232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58233       };
58234     } catch (Dali::DaliException e) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58237       };
58238     } catch (...) {
58239       {
58240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58241       };
58242     }
58243   }
58244
58245 }
58246
58247
58248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58249   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58250   Dali::Actor arg2 ;
58251   bool arg3 ;
58252   Dali::DevelActor::VisibilityChange::Type arg4 ;
58253   Dali::Actor *argp2 ;
58254
58255   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58256   argp2 = (Dali::Actor *)jarg2;
58257   if (!argp2) {
58258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58259     return ;
58260   }
58261   arg2 = *argp2;
58262   arg3 = jarg3 ? true : false;
58263   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58264   {
58265     try {
58266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58267     } catch (std::out_of_range& e) {
58268       {
58269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58270       };
58271     } catch (std::exception& e) {
58272       {
58273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (Dali::DaliException e) {
58276       {
58277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58282       };
58283     }
58284   }
58285
58286 }
58287
58288
58289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58290   void * jresult ;
58291   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58292
58293   {
58294     try {
58295       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58296     } catch (std::out_of_range& e) {
58297       {
58298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58299       };
58300     } catch (std::exception& e) {
58301       {
58302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (Dali::DaliException e) {
58305       {
58306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314
58315   jresult = (void *)result;
58316   return jresult;
58317 }
58318
58319
58320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58321   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58322
58323   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58324   {
58325     try {
58326       delete arg1;
58327     } catch (std::out_of_range& e) {
58328       {
58329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58330       };
58331     } catch (std::exception& e) {
58332       {
58333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58334       };
58335     } catch (Dali::DaliException e) {
58336       {
58337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58338       };
58339     } catch (...) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58342       };
58343     }
58344   }
58345
58346 }
58347
58348
58349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58350   void * jresult ;
58351   Dali::Timer *result = 0 ;
58352
58353   {
58354     try {
58355       result = (Dali::Timer *)new Dali::Timer();
58356     } catch (std::out_of_range& e) {
58357       {
58358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (std::exception& e) {
58361       {
58362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (Dali::DaliException e) {
58365       {
58366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58367       };
58368     } catch (...) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58371       };
58372     }
58373   }
58374
58375   jresult = (void *)result;
58376   return jresult;
58377 }
58378
58379
58380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58381   void * jresult ;
58382   unsigned int arg1 ;
58383   Dali::Timer result;
58384
58385   arg1 = (unsigned int)jarg1;
58386   {
58387     try {
58388       result = Dali::Timer::New(arg1);
58389     } catch (std::out_of_range& e) {
58390       {
58391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58392       };
58393     } catch (std::exception& e) {
58394       {
58395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58396       };
58397     } catch (Dali::DaliException e) {
58398       {
58399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58400       };
58401     } catch (...) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58404       };
58405     }
58406   }
58407
58408   jresult = new Dali::Timer((const Dali::Timer &)result);
58409   return jresult;
58410 }
58411
58412
58413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58414   void * jresult ;
58415   Dali::Timer *arg1 = 0 ;
58416   Dali::Timer *result = 0 ;
58417
58418   arg1 = (Dali::Timer *)jarg1;
58419   if (!arg1) {
58420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58421     return 0;
58422   }
58423   {
58424     try {
58425       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58426     } catch (std::out_of_range& e) {
58427       {
58428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58429       };
58430     } catch (std::exception& e) {
58431       {
58432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (Dali::DaliException e) {
58435       {
58436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58437       };
58438     } catch (...) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58441       };
58442     }
58443   }
58444
58445   jresult = (void *)result;
58446   return jresult;
58447 }
58448
58449
58450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58451   void * jresult ;
58452   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58453   Dali::Timer *arg2 = 0 ;
58454   Dali::Timer *result = 0 ;
58455
58456   arg1 = (Dali::Timer *)jarg1;
58457   arg2 = (Dali::Timer *)jarg2;
58458   if (!arg2) {
58459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58460     return 0;
58461   }
58462   {
58463     try {
58464       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58465     } catch (std::out_of_range& e) {
58466       {
58467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58468       };
58469     } catch (std::exception& e) {
58470       {
58471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (Dali::DaliException e) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58476       };
58477     } catch (...) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58480       };
58481     }
58482   }
58483
58484   jresult = (void *)result;
58485   return jresult;
58486 }
58487
58488
58489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58490   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58491
58492   arg1 = (Dali::Timer *)jarg1;
58493   {
58494     try {
58495       delete arg1;
58496     } catch (std::out_of_range& e) {
58497       {
58498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58499       };
58500     } catch (std::exception& e) {
58501       {
58502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (Dali::DaliException e) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58507       };
58508     } catch (...) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58511       };
58512     }
58513   }
58514
58515 }
58516
58517
58518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58519   void * jresult ;
58520   Dali::BaseHandle arg1 ;
58521   Dali::BaseHandle *argp1 ;
58522   Dali::Timer result;
58523
58524   argp1 = (Dali::BaseHandle *)jarg1;
58525   if (!argp1) {
58526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58527     return 0;
58528   }
58529   arg1 = *argp1;
58530   {
58531     try {
58532       result = Dali::Timer::DownCast(arg1);
58533     } catch (std::out_of_range& e) {
58534       {
58535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58536       };
58537     } catch (std::exception& e) {
58538       {
58539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58540       };
58541     } catch (Dali::DaliException e) {
58542       {
58543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58544       };
58545     } catch (...) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58548       };
58549     }
58550   }
58551
58552   jresult = new Dali::Timer((const Dali::Timer &)result);
58553   return jresult;
58554 }
58555
58556
58557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58558   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58559
58560   arg1 = (Dali::Timer *)jarg1;
58561   {
58562     try {
58563       (arg1)->Start();
58564     } catch (std::out_of_range& e) {
58565       {
58566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58567       };
58568     } catch (std::exception& e) {
58569       {
58570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (Dali::DaliException e) {
58573       {
58574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58575       };
58576     } catch (...) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58579       };
58580     }
58581   }
58582
58583 }
58584
58585
58586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58587   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58588
58589   arg1 = (Dali::Timer *)jarg1;
58590   {
58591     try {
58592       (arg1)->Stop();
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (Dali::DaliException e) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58604       };
58605     } catch (...) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58608       };
58609     }
58610   }
58611
58612 }
58613
58614
58615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58616   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58617   unsigned int arg2 ;
58618
58619   arg1 = (Dali::Timer *)jarg1;
58620   arg2 = (unsigned int)jarg2;
58621   {
58622     try {
58623       (arg1)->SetInterval(arg2);
58624     } catch (std::out_of_range& e) {
58625       {
58626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58627       };
58628     } catch (std::exception& e) {
58629       {
58630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58631       };
58632     } catch (Dali::DaliException e) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58635       };
58636     } catch (...) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58639       };
58640     }
58641   }
58642
58643 }
58644
58645
58646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58647   unsigned int jresult ;
58648   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58649   unsigned int result;
58650
58651   arg1 = (Dali::Timer *)jarg1;
58652   {
58653     try {
58654       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58655     } catch (std::out_of_range& e) {
58656       {
58657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (std::exception& e) {
58660       {
58661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (Dali::DaliException e) {
58664       {
58665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58666       };
58667     } catch (...) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58670       };
58671     }
58672   }
58673
58674   jresult = result;
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58680   unsigned int jresult ;
58681   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58682   bool result;
58683
58684   arg1 = (Dali::Timer *)jarg1;
58685   {
58686     try {
58687       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58688     } catch (std::out_of_range& e) {
58689       {
58690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58691       };
58692     } catch (std::exception& e) {
58693       {
58694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (Dali::DaliException e) {
58697       {
58698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58699       };
58700     } catch (...) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58703       };
58704     }
58705   }
58706
58707   jresult = result;
58708   return jresult;
58709 }
58710
58711
58712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58713   void * jresult ;
58714   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58715   Dali::Timer::TimerSignalType *result = 0 ;
58716
58717   arg1 = (Dali::Timer *)jarg1;
58718   {
58719     try {
58720       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (Dali::DaliException e) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58732       };
58733     } catch (...) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58736       };
58737     }
58738   }
58739
58740   jresult = (void *)result;
58741   return jresult;
58742 }
58743
58744
58745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58746   unsigned int jresult ;
58747   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58748   bool result;
58749
58750   arg1 = (Dali::Signal< bool () > *)jarg1;
58751   {
58752     try {
58753       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58754     } catch (std::out_of_range& e) {
58755       {
58756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58757       };
58758     } catch (std::exception& e) {
58759       {
58760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58761       };
58762     } catch (Dali::DaliException e) {
58763       {
58764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58765       };
58766     } catch (...) {
58767       {
58768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58769       };
58770     }
58771   }
58772
58773   jresult = result;
58774   return jresult;
58775 }
58776
58777
58778 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58779   unsigned long jresult ;
58780   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58781   std::size_t result;
58782
58783   arg1 = (Dali::Signal< bool () > *)jarg1;
58784   {
58785     try {
58786       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58787     } catch (std::out_of_range& e) {
58788       {
58789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58790       };
58791     } catch (std::exception& e) {
58792       {
58793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58794       };
58795     } catch (Dali::DaliException e) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58802       };
58803     }
58804   }
58805
58806   jresult = (unsigned long)result;
58807   return jresult;
58808 }
58809
58810
58811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58812   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58813   bool (*arg2)() = (bool (*)()) 0 ;
58814
58815   arg1 = (Dali::Signal< bool () > *)jarg1;
58816   arg2 = (bool (*)())jarg2;
58817   {
58818     try {
58819       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58820     } catch (std::out_of_range& e) {
58821       {
58822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58823       };
58824     } catch (std::exception& e) {
58825       {
58826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58827       };
58828     } catch (Dali::DaliException e) {
58829       {
58830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58831       };
58832     } catch (...) {
58833       {
58834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58835       };
58836     }
58837   }
58838
58839 }
58840
58841
58842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58843   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58844   bool (*arg2)() = (bool (*)()) 0 ;
58845
58846   arg1 = (Dali::Signal< bool () > *)jarg1;
58847   arg2 = (bool (*)())jarg2;
58848   {
58849     try {
58850       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58851     } catch (std::out_of_range& e) {
58852       {
58853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58854       };
58855     } catch (std::exception& e) {
58856       {
58857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58858       };
58859     } catch (Dali::DaliException e) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58866       };
58867     }
58868   }
58869
58870 }
58871
58872
58873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58874   unsigned int jresult ;
58875   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58876   bool result;
58877
58878   arg1 = (Dali::Signal< bool () > *)jarg1;
58879   {
58880     try {
58881       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58882     } catch (std::out_of_range& e) {
58883       {
58884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58885       };
58886     } catch (std::exception& e) {
58887       {
58888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58889       };
58890     } catch (Dali::DaliException e) {
58891       {
58892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58893       };
58894     } catch (...) {
58895       {
58896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58897       };
58898     }
58899   }
58900
58901   jresult = result;
58902   return jresult;
58903 }
58904
58905
58906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58907   void * jresult ;
58908   Dali::Signal< bool () > *result = 0 ;
58909
58910   {
58911     try {
58912       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
58913     } catch (std::out_of_range& e) {
58914       {
58915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58916       };
58917     } catch (std::exception& e) {
58918       {
58919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (Dali::DaliException e) {
58922       {
58923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58924       };
58925     } catch (...) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58928       };
58929     }
58930   }
58931
58932   jresult = (void *)result;
58933   return jresult;
58934 }
58935
58936
58937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
58938   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58939
58940   arg1 = (Dali::Signal< bool () > *)jarg1;
58941   {
58942     try {
58943       delete arg1;
58944     } catch (std::out_of_range& e) {
58945       {
58946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58947       };
58948     } catch (std::exception& e) {
58949       {
58950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58951       };
58952     } catch (Dali::DaliException e) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58955       };
58956     } catch (...) {
58957       {
58958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58959       };
58960     }
58961   }
58962
58963 }
58964
58965
58966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
58967   int jresult ;
58968   int result;
58969
58970   {
58971     try {
58972       result = (int)Dali::Toolkit::Visual::Property::TYPE;
58973     } catch (std::out_of_range& e) {
58974       {
58975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58976       };
58977     } catch (std::exception& e) {
58978       {
58979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (Dali::DaliException e) {
58982       {
58983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58984       };
58985     } catch (...) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58988       };
58989     }
58990   }
58991
58992   jresult = (int)result;
58993   return jresult;
58994 }
58995
58996
58997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
58998   int jresult ;
58999   int result;
59000
59001   {
59002     try {
59003       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59004     } catch (std::out_of_range& e) {
59005       {
59006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59007       };
59008     } catch (std::exception& e) {
59009       {
59010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59011       };
59012     } catch (Dali::DaliException e) {
59013       {
59014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59015       };
59016     } catch (...) {
59017       {
59018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59019       };
59020     }
59021   }
59022
59023   jresult = (int)result;
59024   return jresult;
59025 }
59026
59027
59028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59029   int jresult ;
59030   int result;
59031
59032   {
59033     try {
59034       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59035     } catch (std::out_of_range& e) {
59036       {
59037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59038       };
59039     } catch (std::exception& e) {
59040       {
59041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59042       };
59043     } catch (Dali::DaliException e) {
59044       {
59045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59046       };
59047     } catch (...) {
59048       {
59049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59050       };
59051     }
59052   }
59053
59054   jresult = (int)result;
59055   return jresult;
59056 }
59057
59058
59059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59060   int jresult ;
59061   int result;
59062
59063   {
59064     try {
59065       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59066     } catch (std::out_of_range& e) {
59067       {
59068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59069       };
59070     } catch (std::exception& e) {
59071       {
59072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59073       };
59074     } catch (Dali::DaliException e) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59077       };
59078     } catch (...) {
59079       {
59080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59081       };
59082     }
59083   }
59084
59085   jresult = (int)result;
59086   return jresult;
59087 }
59088
59089
59090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59091   int jresult ;
59092   int result;
59093
59094   {
59095     try {
59096       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59097     } catch (std::out_of_range& e) {
59098       {
59099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59100       };
59101     } catch (std::exception& e) {
59102       {
59103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59104       };
59105     } catch (Dali::DaliException e) {
59106       {
59107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59108       };
59109     } catch (...) {
59110       {
59111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59112       };
59113     }
59114   }
59115
59116   jresult = (int)result;
59117   return jresult;
59118 }
59119
59120
59121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59122   int jresult ;
59123   int result;
59124
59125   {
59126     try {
59127       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59128     } catch (std::out_of_range& e) {
59129       {
59130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59131       };
59132     } catch (std::exception& e) {
59133       {
59134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59135       };
59136     } catch (Dali::DaliException e) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59139       };
59140     } catch (...) {
59141       {
59142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59143       };
59144     }
59145   }
59146
59147   jresult = (int)result;
59148   return jresult;
59149 }
59150
59151
59152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59153   int jresult ;
59154   int result;
59155
59156   {
59157     try {
59158       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59159     } catch (std::out_of_range& e) {
59160       {
59161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59162       };
59163     } catch (std::exception& e) {
59164       {
59165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59166       };
59167     } catch (Dali::DaliException e) {
59168       {
59169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59170       };
59171     } catch (...) {
59172       {
59173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59174       };
59175     }
59176   }
59177
59178   jresult = (int)result;
59179   return jresult;
59180 }
59181
59182
59183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59184   int jresult ;
59185   int result;
59186
59187   {
59188     try {
59189       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59190     } catch (std::out_of_range& e) {
59191       {
59192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59193       };
59194     } catch (std::exception& e) {
59195       {
59196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59197       };
59198     } catch (Dali::DaliException e) {
59199       {
59200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59201       };
59202     } catch (...) {
59203       {
59204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59205       };
59206     }
59207   }
59208
59209   jresult = (int)result;
59210   return jresult;
59211 }
59212
59213
59214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59215   int jresult ;
59216   int result;
59217
59218   {
59219     try {
59220       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59221     } catch (std::out_of_range& e) {
59222       {
59223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59224       };
59225     } catch (std::exception& e) {
59226       {
59227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59228       };
59229     } catch (Dali::DaliException e) {
59230       {
59231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59232       };
59233     } catch (...) {
59234       {
59235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59236       };
59237     }
59238   }
59239
59240   jresult = (int)result;
59241   return jresult;
59242 }
59243
59244
59245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59246   int jresult ;
59247   int result;
59248
59249   {
59250     try {
59251       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59252     } catch (std::out_of_range& e) {
59253       {
59254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59255       };
59256     } catch (std::exception& e) {
59257       {
59258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59259       };
59260     } catch (Dali::DaliException e) {
59261       {
59262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59263       };
59264     } catch (...) {
59265       {
59266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59267       };
59268     }
59269   }
59270
59271   jresult = (int)result;
59272   return jresult;
59273 }
59274
59275
59276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59277   int jresult ;
59278   int result;
59279
59280   {
59281     try {
59282       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59283     } catch (std::out_of_range& e) {
59284       {
59285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (std::exception& e) {
59288       {
59289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59290       };
59291     } catch (Dali::DaliException e) {
59292       {
59293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59294       };
59295     } catch (...) {
59296       {
59297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59298       };
59299     }
59300   }
59301
59302   jresult = (int)result;
59303   return jresult;
59304 }
59305
59306
59307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59308   int jresult ;
59309   int result;
59310
59311   {
59312     try {
59313       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59314     } catch (std::out_of_range& e) {
59315       {
59316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (std::exception& e) {
59319       {
59320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59321       };
59322     } catch (Dali::DaliException e) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59325       };
59326     } catch (...) {
59327       {
59328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59329       };
59330     }
59331   }
59332
59333   jresult = (int)result;
59334   return jresult;
59335 }
59336
59337
59338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59339   int jresult ;
59340   int result;
59341
59342   {
59343     try {
59344       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59345     } catch (std::out_of_range& e) {
59346       {
59347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59348       };
59349     } catch (std::exception& e) {
59350       {
59351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59352       };
59353     } catch (Dali::DaliException e) {
59354       {
59355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59356       };
59357     } catch (...) {
59358       {
59359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59360       };
59361     }
59362   }
59363
59364   jresult = (int)result;
59365   return jresult;
59366 }
59367
59368
59369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59370   int jresult ;
59371   int result;
59372
59373   {
59374     try {
59375       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59376     } catch (std::out_of_range& e) {
59377       {
59378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59379       };
59380     } catch (std::exception& e) {
59381       {
59382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59383       };
59384     } catch (Dali::DaliException e) {
59385       {
59386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59387       };
59388     } catch (...) {
59389       {
59390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59391       };
59392     }
59393   }
59394
59395   jresult = (int)result;
59396   return jresult;
59397 }
59398
59399
59400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59401   int jresult ;
59402   int result;
59403
59404   {
59405     try {
59406       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59407     } catch (std::out_of_range& e) {
59408       {
59409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59410       };
59411     } catch (std::exception& e) {
59412       {
59413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59414       };
59415     } catch (Dali::DaliException e) {
59416       {
59417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59418       };
59419     } catch (...) {
59420       {
59421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59422       };
59423     }
59424   }
59425
59426   jresult = (int)result;
59427   return jresult;
59428 }
59429
59430
59431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59432   int jresult ;
59433   int result;
59434
59435   {
59436     try {
59437       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59438     } catch (std::out_of_range& e) {
59439       {
59440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59441       };
59442     } catch (std::exception& e) {
59443       {
59444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59445       };
59446     } catch (Dali::DaliException e) {
59447       {
59448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59449       };
59450     } catch (...) {
59451       {
59452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59453       };
59454     }
59455   }
59456
59457   jresult = (int)result;
59458   return jresult;
59459 }
59460
59461
59462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59463   int jresult ;
59464   int result;
59465
59466   {
59467     try {
59468       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59469     } catch (std::out_of_range& e) {
59470       {
59471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59472       };
59473     } catch (std::exception& e) {
59474       {
59475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59476       };
59477     } catch (Dali::DaliException e) {
59478       {
59479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59480       };
59481     } catch (...) {
59482       {
59483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59484       };
59485     }
59486   }
59487
59488   jresult = (int)result;
59489   return jresult;
59490 }
59491
59492
59493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59494   int jresult ;
59495   int result;
59496
59497   {
59498     try {
59499       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59500     } catch (std::out_of_range& e) {
59501       {
59502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59503       };
59504     } catch (std::exception& e) {
59505       {
59506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59507       };
59508     } catch (Dali::DaliException e) {
59509       {
59510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59511       };
59512     } catch (...) {
59513       {
59514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59515       };
59516     }
59517   }
59518
59519   jresult = (int)result;
59520   return jresult;
59521 }
59522
59523
59524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59525   int jresult ;
59526   int result;
59527
59528   {
59529     try {
59530       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59531     } catch (std::out_of_range& e) {
59532       {
59533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59534       };
59535     } catch (std::exception& e) {
59536       {
59537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (Dali::DaliException e) {
59540       {
59541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59542       };
59543     } catch (...) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59546       };
59547     }
59548   }
59549
59550   jresult = (int)result;
59551   return jresult;
59552 }
59553
59554
59555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59556   int jresult ;
59557   int result;
59558
59559   {
59560     try {
59561       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59562     } catch (std::out_of_range& e) {
59563       {
59564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59565       };
59566     } catch (std::exception& e) {
59567       {
59568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59569       };
59570     } catch (Dali::DaliException e) {
59571       {
59572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59573       };
59574     } catch (...) {
59575       {
59576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59577       };
59578     }
59579   }
59580
59581   jresult = (int)result;
59582   return jresult;
59583 }
59584
59585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59586   int jresult ;
59587   int result;
59588
59589   {
59590     try {
59591       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59592     } catch (std::out_of_range& e) {
59593       {
59594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59595       };
59596     } catch (std::exception& e) {
59597       {
59598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59599       };
59600     } catch (Dali::DaliException e) {
59601       {
59602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59603       };
59604     } catch (...) {
59605       {
59606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59607       };
59608     }
59609   }
59610
59611   jresult = (int)result;
59612   return jresult;
59613 }
59614
59615
59616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59617   int jresult ;
59618   int result;
59619   {
59620     try
59621     {
59622       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59623     } catch (std::out_of_range& e) {
59624       {
59625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (std::exception& e) {
59628       {
59629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (Dali::DaliException e) {
59632       {
59633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59634       };
59635     } catch (...) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59638       };
59639     }
59640   }
59641
59642   jresult = (int)result;
59643   return jresult;
59644 }
59645
59646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59647   int jresult ;
59648   int result;
59649   {
59650     try
59651     {
59652       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59653     } catch (std::out_of_range& e) {
59654       {
59655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59656       };
59657     } catch (std::exception& e) {
59658       {
59659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59660       };
59661     } catch (Dali::DaliException e) {
59662       {
59663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59664       };
59665     } catch (...) {
59666       {
59667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59668       };
59669     }
59670   }
59671
59672   jresult = (int)result;
59673   return jresult;
59674 }
59675
59676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59677   int jresult ;
59678   int result;
59679   {
59680     try
59681     {
59682       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59683     } catch (std::out_of_range& e) {
59684       {
59685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59686       };
59687     } catch (std::exception& e) {
59688       {
59689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59690       };
59691     } catch (Dali::DaliException e) {
59692       {
59693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59694       };
59695     } catch (...) {
59696       {
59697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59698       };
59699     }
59700   }
59701
59702   jresult = (int)result;
59703   return jresult;
59704 }
59705
59706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59707   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59708 }
59709
59710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59711   int jresult ;
59712   int result;
59713   {
59714     try
59715     {
59716       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59717     } catch (std::out_of_range& e) {
59718       {
59719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (std::exception& e) {
59722       {
59723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (Dali::DaliException e) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59728       };
59729     } catch (...) {
59730       {
59731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59732       };
59733     }
59734   }
59735
59736   jresult = (int)result;
59737   return jresult;
59738 }
59739
59740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59741   int jresult ;
59742   int result;
59743   {
59744     try
59745     {
59746       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59747     } catch (std::out_of_range& e) {
59748       {
59749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (std::exception& e) {
59752       {
59753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59754       };
59755     } catch (Dali::DaliException e) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59758       };
59759     } catch (...) {
59760       {
59761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59762       };
59763     }
59764   }
59765
59766   jresult = (int)result;
59767   return jresult;
59768 }
59769
59770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59771   int jresult ;
59772   int result;
59773
59774   {
59775     try {
59776       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59777     } catch (std::out_of_range& e) {
59778       {
59779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (std::exception& e) {
59782       {
59783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59784       };
59785     } catch (Dali::DaliException e) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59788       };
59789     } catch (...) {
59790       {
59791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59792       };
59793     }
59794   }
59795
59796   jresult = (int)result;
59797   return jresult;
59798 }
59799
59800
59801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59802   int jresult ;
59803   int result;
59804
59805   {
59806     try {
59807       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59808     } catch (std::out_of_range& e) {
59809       {
59810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59811       };
59812     } catch (std::exception& e) {
59813       {
59814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59815       };
59816     } catch (Dali::DaliException e) {
59817       {
59818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59819       };
59820     } catch (...) {
59821       {
59822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59823       };
59824     }
59825   }
59826
59827   jresult = (int)result;
59828   return jresult;
59829 }
59830
59831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59832   int jresult ;
59833   int result;
59834   {
59835     try
59836     {
59837       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59838     } catch (std::out_of_range& e) {
59839       {
59840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59841       };
59842     } catch (std::exception& e) {
59843       {
59844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59845       };
59846     } catch (...) {
59847       {
59848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59849       };
59850     }
59851   }
59852   jresult = (int)result;
59853   return jresult;
59854 }
59855
59856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59857   int jresult ;
59858   int result;
59859   {
59860     try
59861     {
59862       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59863     } catch (std::out_of_range& e) {
59864       {
59865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59866       };
59867     } catch (std::exception& e) {
59868       {
59869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (...) {
59872       {
59873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59874       };
59875     }
59876   }
59877   jresult = (int)result;
59878   return jresult;
59879 }
59880
59881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59882   int jresult ;
59883   int result;
59884   {
59885     try
59886     {
59887       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59888     } catch (std::out_of_range& e) {
59889       {
59890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59891       };
59892     } catch (std::exception& e) {
59893       {
59894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (...) {
59897       {
59898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59899       };
59900     }
59901   }
59902   jresult = (int)result;
59903   return jresult;
59904 }
59905
59906
59907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59908   int jresult ;
59909   int result;
59910   {
59911     try
59912     {
59913       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
59914     } catch (std::out_of_range& e) {
59915       {
59916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59917       };
59918     } catch (std::exception& e) {
59919       {
59920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59921       };
59922     } catch (...) {
59923       {
59924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59925       };
59926     }
59927   }
59928   jresult = (int)result;
59929   return jresult;
59930 }
59931
59932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
59933   int jresult ;
59934   int result;
59935   {
59936     try
59937     {
59938       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
59939     } catch (std::out_of_range& e) {
59940       {
59941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59942       };
59943     } catch (std::exception& e) {
59944       {
59945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59946       };
59947     } catch (...) {
59948       {
59949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59950       };
59951     }
59952   }
59953   jresult = (int)result;
59954   return jresult;
59955 }
59956
59957
59958
59959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
59960   int jresult ;
59961   int result;
59962
59963   {
59964     try {
59965       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
59966     } catch (std::out_of_range& e) {
59967       {
59968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59969       };
59970     } catch (std::exception& e) {
59971       {
59972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59973       };
59974     } catch (Dali::DaliException e) {
59975       {
59976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59977       };
59978     } catch (...) {
59979       {
59980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59981       };
59982     }
59983   }
59984
59985   jresult = (int)result;
59986   return jresult;
59987 }
59988
59989
59990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
59991   int jresult ;
59992   int result;
59993
59994   {
59995     try {
59996       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
59997     } catch (std::out_of_range& e) {
59998       {
59999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60000       };
60001     } catch (std::exception& e) {
60002       {
60003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60004       };
60005     } catch (Dali::DaliException e) {
60006       {
60007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60008       };
60009     } catch (...) {
60010       {
60011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60012       };
60013     }
60014   }
60015
60016   jresult = (int)result;
60017   return jresult;
60018 }
60019
60020
60021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60022   int jresult ;
60023   int result;
60024
60025   {
60026     try {
60027       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60028     } catch (std::out_of_range& e) {
60029       {
60030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (std::exception& e) {
60033       {
60034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60035       };
60036     } catch (Dali::DaliException e) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60039       };
60040     } catch (...) {
60041       {
60042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60043       };
60044     }
60045   }
60046
60047   jresult = (int)result;
60048   return jresult;
60049 }
60050
60051
60052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60053   int jresult ;
60054   int result;
60055
60056   {
60057     try {
60058       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60066       };
60067     } catch (Dali::DaliException e) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60070       };
60071     } catch (...) {
60072       {
60073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60074       };
60075     }
60076   }
60077
60078   jresult = (int)result;
60079   return jresult;
60080 }
60081
60082
60083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60084   int jresult ;
60085   int result;
60086
60087   {
60088     try {
60089       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60090     } catch (std::out_of_range& e) {
60091       {
60092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60093       };
60094     } catch (std::exception& e) {
60095       {
60096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60097       };
60098     } catch (Dali::DaliException e) {
60099       {
60100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60101       };
60102     } catch (...) {
60103       {
60104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60105       };
60106     }
60107   }
60108
60109   jresult = (int)result;
60110   return jresult;
60111 }
60112
60113
60114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60115   int jresult ;
60116   int result;
60117
60118   {
60119     try {
60120       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60121     } catch (std::out_of_range& e) {
60122       {
60123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60124       };
60125     } catch (std::exception& e) {
60126       {
60127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60128       };
60129     } catch (Dali::DaliException e) {
60130       {
60131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60132       };
60133     } catch (...) {
60134       {
60135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60136       };
60137     }
60138   }
60139
60140   jresult = (int)result;
60141   return jresult;
60142 }
60143
60144
60145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60146   int jresult ;
60147   int result;
60148
60149   {
60150     try {
60151       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60152     } catch (std::out_of_range& e) {
60153       {
60154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60155       };
60156     } catch (std::exception& e) {
60157       {
60158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60159       };
60160     } catch (Dali::DaliException e) {
60161       {
60162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60163       };
60164     } catch (...) {
60165       {
60166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60167       };
60168     }
60169   }
60170
60171   jresult = (int)result;
60172   return jresult;
60173 }
60174
60175 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60176   int jresult ;
60177   int result;
60178
60179   {
60180     try {
60181       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60182     } catch (std::out_of_range& e) {
60183       {
60184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60185       };
60186     } catch (std::exception& e) {
60187       {
60188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60189       };
60190     } catch (...) {
60191       {
60192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60193       };
60194     }
60195   }
60196   jresult = (int)result;
60197   return jresult;
60198 }
60199
60200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60201   int jresult ;
60202   int result;
60203
60204   {
60205     try {
60206       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60207     } catch (std::out_of_range& e) {
60208       {
60209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60210       };
60211     } catch (std::exception& e) {
60212       {
60213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (Dali::DaliException e) {
60216       {
60217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60218       };
60219     } catch (...) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60222       };
60223     }
60224   }
60225
60226   jresult = (int)result;
60227   return jresult;
60228 }
60229
60230
60231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60232   int jresult ;
60233   int result;
60234
60235   {
60236     try {
60237       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60238     } catch (std::out_of_range& e) {
60239       {
60240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60241       };
60242     } catch (std::exception& e) {
60243       {
60244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60245       };
60246     } catch (Dali::DaliException e) {
60247       {
60248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60249       };
60250     } catch (...) {
60251       {
60252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60253       };
60254     }
60255   }
60256
60257   jresult = (int)result;
60258   return jresult;
60259 }
60260
60261
60262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60263   int jresult ;
60264   int result;
60265
60266   {
60267     try {
60268       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (Dali::DaliException e) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60284       };
60285     }
60286   }
60287
60288   jresult = (int)result;
60289   return jresult;
60290 }
60291
60292
60293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60294   int jresult ;
60295   int result;
60296
60297   {
60298     try {
60299       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60300     } catch (std::out_of_range& e) {
60301       {
60302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (std::exception& e) {
60305       {
60306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60307       };
60308     } catch (Dali::DaliException e) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60311       };
60312     } catch (...) {
60313       {
60314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60315       };
60316     }
60317   }
60318
60319   jresult = (int)result;
60320   return jresult;
60321 }
60322
60323
60324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60325   int jresult ;
60326   int result;
60327
60328   {
60329     try {
60330       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60331     } catch (std::out_of_range& e) {
60332       {
60333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (std::exception& e) {
60336       {
60337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60338       };
60339     } catch (Dali::DaliException e) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60342       };
60343     } catch (...) {
60344       {
60345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60346       };
60347     }
60348   }
60349
60350   jresult = (int)result;
60351   return jresult;
60352 }
60353
60354
60355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60356   int jresult ;
60357   int result;
60358
60359   {
60360     try {
60361       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60362     } catch (std::out_of_range& e) {
60363       {
60364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60365       };
60366     } catch (std::exception& e) {
60367       {
60368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60369       };
60370     } catch (Dali::DaliException e) {
60371       {
60372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60373       };
60374     } catch (...) {
60375       {
60376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60377       };
60378     }
60379   }
60380
60381   jresult = (int)result;
60382   return jresult;
60383 }
60384
60385
60386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60387   int jresult ;
60388   int result;
60389
60390   {
60391     try {
60392       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60393     } catch (std::out_of_range& e) {
60394       {
60395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60396       };
60397     } catch (std::exception& e) {
60398       {
60399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60400       };
60401     } catch (Dali::DaliException e) {
60402       {
60403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60404       };
60405     } catch (...) {
60406       {
60407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60408       };
60409     }
60410   }
60411
60412   jresult = (int)result;
60413   return jresult;
60414 }
60415
60416
60417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60418   int jresult ;
60419   int result;
60420
60421   {
60422     try {
60423       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60424     } catch (std::out_of_range& e) {
60425       {
60426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60427       };
60428     } catch (std::exception& e) {
60429       {
60430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60431       };
60432     } catch (Dali::DaliException e) {
60433       {
60434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60435       };
60436     } catch (...) {
60437       {
60438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60439       };
60440     }
60441   }
60442
60443   jresult = (int)result;
60444   return jresult;
60445 }
60446
60447
60448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60449   int jresult ;
60450   int result;
60451
60452   {
60453     try {
60454       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60455     } catch (std::out_of_range& e) {
60456       {
60457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60458       };
60459     } catch (std::exception& e) {
60460       {
60461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60462       };
60463     } catch (Dali::DaliException e) {
60464       {
60465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60466       };
60467     } catch (...) {
60468       {
60469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60470       };
60471     }
60472   }
60473
60474   jresult = (int)result;
60475   return jresult;
60476 }
60477
60478
60479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60480   int jresult ;
60481   int result;
60482
60483   {
60484     try {
60485       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60486     } catch (std::out_of_range& e) {
60487       {
60488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60489       };
60490     } catch (std::exception& e) {
60491       {
60492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60493       };
60494     } catch (Dali::DaliException e) {
60495       {
60496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60497       };
60498     } catch (...) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60501       };
60502     }
60503   }
60504
60505   jresult = (int)result;
60506   return jresult;
60507 }
60508
60509
60510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60511   int jresult ;
60512   int result;
60513
60514   {
60515     try {
60516       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60517     } catch (std::out_of_range& e) {
60518       {
60519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60520       };
60521     } catch (std::exception& e) {
60522       {
60523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60524       };
60525     } catch (Dali::DaliException e) {
60526       {
60527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60528       };
60529     } catch (...) {
60530       {
60531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60532       };
60533     }
60534   }
60535
60536   jresult = (int)result;
60537   return jresult;
60538 }
60539
60540
60541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60542   int jresult ;
60543   int result;
60544
60545   {
60546     try {
60547       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60548     } catch (std::out_of_range& e) {
60549       {
60550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60551       };
60552     } catch (std::exception& e) {
60553       {
60554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60555       };
60556     } catch (Dali::DaliException e) {
60557       {
60558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60559       };
60560     } catch (...) {
60561       {
60562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60563       };
60564     }
60565   }
60566
60567   jresult = (int)result;
60568   return jresult;
60569 }
60570
60571
60572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60573   int jresult ;
60574   int result;
60575
60576   {
60577     try {
60578       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60579     } catch (std::out_of_range& e) {
60580       {
60581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60582       };
60583     } catch (std::exception& e) {
60584       {
60585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60586       };
60587     } catch (Dali::DaliException e) {
60588       {
60589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60590       };
60591     } catch (...) {
60592       {
60593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60594       };
60595     }
60596   }
60597
60598   jresult = (int)result;
60599   return jresult;
60600 }
60601
60602
60603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60604   int jresult ;
60605   int result;
60606
60607   {
60608     try {
60609       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60610     } catch (std::out_of_range& e) {
60611       {
60612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60613       };
60614     } catch (std::exception& e) {
60615       {
60616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60617       };
60618     } catch (Dali::DaliException e) {
60619       {
60620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60621       };
60622     } catch (...) {
60623       {
60624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60625       };
60626     }
60627   }
60628
60629   jresult = (int)result;
60630   return jresult;
60631 }
60632
60633
60634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60635   int jresult ;
60636   int result;
60637
60638   {
60639     try {
60640       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60641     } catch (std::out_of_range& e) {
60642       {
60643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60644       };
60645     } catch (std::exception& e) {
60646       {
60647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60648       };
60649     } catch (Dali::DaliException e) {
60650       {
60651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60652       };
60653     } catch (...) {
60654       {
60655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60656       };
60657     }
60658   }
60659
60660   jresult = (int)result;
60661   return jresult;
60662 }
60663
60664
60665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60666   int jresult ;
60667   int result;
60668
60669   {
60670     try {
60671       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60672     } catch (std::out_of_range& e) {
60673       {
60674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60675       };
60676     } catch (std::exception& e) {
60677       {
60678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60679       };
60680     } catch (Dali::DaliException e) {
60681       {
60682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60683       };
60684     } catch (...) {
60685       {
60686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60687       };
60688     }
60689   }
60690
60691   jresult = (int)result;
60692   return jresult;
60693 }
60694
60695
60696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60697   int jresult ;
60698   int result;
60699
60700   {
60701     try {
60702       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60703     } catch (std::out_of_range& e) {
60704       {
60705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60706       };
60707     } catch (std::exception& e) {
60708       {
60709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60710       };
60711     } catch (Dali::DaliException e) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60714       };
60715     } catch (...) {
60716       {
60717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60718       };
60719     }
60720   }
60721
60722   jresult = (int)result;
60723   return jresult;
60724 }
60725
60726
60727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60728   int jresult ;
60729   int result;
60730
60731   {
60732     try {
60733       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60734     } catch (std::out_of_range& e) {
60735       {
60736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60737       };
60738     } catch (std::exception& e) {
60739       {
60740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60741       };
60742     } catch (Dali::DaliException e) {
60743       {
60744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60745       };
60746     } catch (...) {
60747       {
60748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60749       };
60750     }
60751   }
60752
60753   jresult = (int)result;
60754   return jresult;
60755 }
60756
60757
60758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60759   int jresult ;
60760   int result;
60761
60762   {
60763     try {
60764       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60765     } catch (std::out_of_range& e) {
60766       {
60767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60768       };
60769     } catch (std::exception& e) {
60770       {
60771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60772       };
60773     } catch (Dali::DaliException e) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60776       };
60777     } catch (...) {
60778       {
60779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60780       };
60781     }
60782   }
60783
60784   jresult = (int)result;
60785   return jresult;
60786 }
60787
60788
60789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60790   int jresult ;
60791   int result;
60792
60793   {
60794     try {
60795       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60796     } catch (std::out_of_range& e) {
60797       {
60798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60799       };
60800     } catch (std::exception& e) {
60801       {
60802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60803       };
60804     } catch (Dali::DaliException e) {
60805       {
60806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60807       };
60808     } catch (...) {
60809       {
60810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60811       };
60812     }
60813   }
60814
60815   jresult = (int)result;
60816   return jresult;
60817 }
60818
60819
60820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60821   int jresult ;
60822   int result;
60823
60824   {
60825     try {
60826       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60827     } catch (std::out_of_range& e) {
60828       {
60829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60830       };
60831     } catch (std::exception& e) {
60832       {
60833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60834       };
60835     } catch (Dali::DaliException e) {
60836       {
60837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60838       };
60839     } catch (...) {
60840       {
60841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60842       };
60843     }
60844   }
60845
60846   jresult = (int)result;
60847   return jresult;
60848 }
60849
60850
60851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60852   int jresult ;
60853   int result;
60854
60855   {
60856     try {
60857       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60858     } catch (std::out_of_range& e) {
60859       {
60860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60861       };
60862     } catch (std::exception& e) {
60863       {
60864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60865       };
60866     } catch (Dali::DaliException e) {
60867       {
60868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60869       };
60870     } catch (...) {
60871       {
60872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60873       };
60874     }
60875   }
60876
60877   jresult = (int)result;
60878   return jresult;
60879 }
60880
60881
60882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60883   int jresult ;
60884   int result;
60885
60886   {
60887     try {
60888       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60889     } catch (std::out_of_range& e) {
60890       {
60891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60892       };
60893     } catch (std::exception& e) {
60894       {
60895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60896       };
60897     } catch (Dali::DaliException e) {
60898       {
60899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60900       };
60901     } catch (...) {
60902       {
60903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60904       };
60905     }
60906   }
60907
60908   jresult = (int)result;
60909   return jresult;
60910 }
60911
60912
60913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
60914   int jresult ;
60915   int result;
60916
60917   {
60918     try {
60919       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
60920     } catch (std::out_of_range& e) {
60921       {
60922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (std::exception& e) {
60925       {
60926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60927       };
60928     } catch (Dali::DaliException e) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60931       };
60932     } catch (...) {
60933       {
60934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60935       };
60936     }
60937   }
60938
60939   jresult = (int)result;
60940   return jresult;
60941 }
60942
60943
60944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
60945   int jresult ;
60946   int result;
60947
60948   {
60949     try {
60950       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
60951     } catch (std::out_of_range& e) {
60952       {
60953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60954       };
60955     } catch (std::exception& e) {
60956       {
60957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60958       };
60959     } catch (Dali::DaliException e) {
60960       {
60961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60962       };
60963     } catch (...) {
60964       {
60965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60966       };
60967     }
60968   }
60969
60970   jresult = (int)result;
60971   return jresult;
60972 }
60973
60974
60975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
60976   int jresult ;
60977   int result;
60978
60979   {
60980     try {
60981       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
60982     } catch (std::out_of_range& e) {
60983       {
60984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60985       };
60986     } catch (std::exception& e) {
60987       {
60988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60989       };
60990     } catch (Dali::DaliException e) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60993       };
60994     } catch (...) {
60995       {
60996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60997       };
60998     }
60999   }
61000
61001   jresult = (int)result;
61002   return jresult;
61003 }
61004
61005
61006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61007   int jresult ;
61008   int result;
61009
61010   {
61011     try {
61012       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61013     } catch (std::out_of_range& e) {
61014       {
61015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (std::exception& e) {
61018       {
61019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61020       };
61021     } catch (Dali::DaliException e) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61024       };
61025     } catch (...) {
61026       {
61027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61028       };
61029     }
61030   }
61031
61032   jresult = (int)result;
61033   return jresult;
61034 }
61035
61036
61037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61038   int jresult ;
61039   int result;
61040
61041   {
61042     try {
61043       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61044     } catch (std::out_of_range& e) {
61045       {
61046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61047       };
61048     } catch (std::exception& e) {
61049       {
61050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61051       };
61052     } catch (Dali::DaliException e) {
61053       {
61054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61055       };
61056     } catch (...) {
61057       {
61058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61059       };
61060     }
61061   }
61062
61063   jresult = (int)result;
61064   return jresult;
61065 }
61066
61067
61068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61069   void * jresult ;
61070   Dali::Toolkit::Builder *result = 0 ;
61071
61072   {
61073     try {
61074       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61075     } catch (std::out_of_range& e) {
61076       {
61077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61078       };
61079     } catch (std::exception& e) {
61080       {
61081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61082       };
61083     } catch (Dali::DaliException e) {
61084       {
61085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61086       };
61087     } catch (...) {
61088       {
61089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61090       };
61091     }
61092   }
61093
61094   jresult = (void *)result;
61095   return jresult;
61096 }
61097
61098
61099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61100   void * jresult ;
61101   Dali::Toolkit::Builder result;
61102
61103   {
61104     try {
61105       result = Dali::Toolkit::Builder::New();
61106     } catch (std::out_of_range& e) {
61107       {
61108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61109       };
61110     } catch (std::exception& e) {
61111       {
61112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61113       };
61114     } catch (Dali::DaliException e) {
61115       {
61116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61117       };
61118     } catch (...) {
61119       {
61120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61121       };
61122     }
61123   }
61124
61125   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61126   return jresult;
61127 }
61128
61129
61130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61131   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61132
61133   arg1 = (Dali::Toolkit::Builder *)jarg1;
61134   {
61135     try {
61136       delete arg1;
61137     } catch (std::out_of_range& e) {
61138       {
61139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61140       };
61141     } catch (std::exception& e) {
61142       {
61143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61144       };
61145     } catch (Dali::DaliException e) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61148       };
61149     } catch (...) {
61150       {
61151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61152       };
61153     }
61154   }
61155
61156 }
61157
61158
61159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61160   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61161   std::string *arg2 = 0 ;
61162   Dali::Toolkit::Builder::UIFormat arg3 ;
61163
61164   arg1 = (Dali::Toolkit::Builder *)jarg1;
61165   if (!jarg2) {
61166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61167     return ;
61168   }
61169   std::string arg2_str(jarg2);
61170   arg2 = &arg2_str;
61171   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61172   {
61173     try {
61174       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61182       };
61183     } catch (Dali::DaliException e) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61186       };
61187     } catch (...) {
61188       {
61189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61190       };
61191     }
61192   }
61193
61194
61195   //argout typemap for const std::string&
61196
61197 }
61198
61199
61200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61201   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61202   std::string *arg2 = 0 ;
61203
61204   arg1 = (Dali::Toolkit::Builder *)jarg1;
61205   if (!jarg2) {
61206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61207     return ;
61208   }
61209   std::string arg2_str(jarg2);
61210   arg2 = &arg2_str;
61211   {
61212     try {
61213       (arg1)->LoadFromString((std::string const &)*arg2);
61214     } catch (std::out_of_range& e) {
61215       {
61216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61217       };
61218     } catch (std::exception& e) {
61219       {
61220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61221       };
61222     } catch (Dali::DaliException e) {
61223       {
61224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61225       };
61226     } catch (...) {
61227       {
61228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61229       };
61230     }
61231   }
61232
61233
61234   //argout typemap for const std::string&
61235
61236 }
61237
61238
61239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61240   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61241   Dali::Property::Map *arg2 = 0 ;
61242
61243   arg1 = (Dali::Toolkit::Builder *)jarg1;
61244   arg2 = (Dali::Property::Map *)jarg2;
61245   if (!arg2) {
61246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61247     return ;
61248   }
61249   {
61250     try {
61251       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61252     } catch (std::out_of_range& e) {
61253       {
61254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61255       };
61256     } catch (std::exception& e) {
61257       {
61258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61259       };
61260     } catch (Dali::DaliException e) {
61261       {
61262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61263       };
61264     } catch (...) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61267       };
61268     }
61269   }
61270
61271 }
61272
61273
61274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61275   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61276   std::string *arg2 = 0 ;
61277   Dali::Property::Value *arg3 = 0 ;
61278
61279   arg1 = (Dali::Toolkit::Builder *)jarg1;
61280   if (!jarg2) {
61281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61282     return ;
61283   }
61284   std::string arg2_str(jarg2);
61285   arg2 = &arg2_str;
61286   arg3 = (Dali::Property::Value *)jarg3;
61287   if (!arg3) {
61288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61289     return ;
61290   }
61291   {
61292     try {
61293       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61294     } catch (std::out_of_range& e) {
61295       {
61296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61297       };
61298     } catch (std::exception& e) {
61299       {
61300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61301       };
61302     } catch (Dali::DaliException e) {
61303       {
61304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61305       };
61306     } catch (...) {
61307       {
61308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61309       };
61310     }
61311   }
61312
61313
61314   //argout typemap for const std::string&
61315
61316 }
61317
61318
61319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61320   void * jresult ;
61321   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61322   Dali::Property::Map *result = 0 ;
61323
61324   arg1 = (Dali::Toolkit::Builder *)jarg1;
61325   {
61326     try {
61327       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61328     } catch (std::out_of_range& e) {
61329       {
61330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61331       };
61332     } catch (std::exception& e) {
61333       {
61334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61335       };
61336     } catch (Dali::DaliException e) {
61337       {
61338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61339       };
61340     } catch (...) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61343       };
61344     }
61345   }
61346
61347   jresult = (void *)result;
61348   return jresult;
61349 }
61350
61351
61352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61353   void * jresult ;
61354   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61355   std::string *arg2 = 0 ;
61356   Dali::Property::Value *result = 0 ;
61357
61358   arg1 = (Dali::Toolkit::Builder *)jarg1;
61359   if (!jarg2) {
61360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61361     return 0;
61362   }
61363   std::string arg2_str(jarg2);
61364   arg2 = &arg2_str;
61365   {
61366     try {
61367       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61368     } catch (std::out_of_range& e) {
61369       {
61370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61371       };
61372     } catch (std::exception& e) {
61373       {
61374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61375       };
61376     } catch (Dali::DaliException e) {
61377       {
61378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61379       };
61380     } catch (...) {
61381       {
61382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61383       };
61384     }
61385   }
61386
61387   jresult = (void *)result;
61388
61389   //argout typemap for const std::string&
61390
61391   return jresult;
61392 }
61393
61394
61395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61396   void * jresult ;
61397   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61398   std::string *arg2 = 0 ;
61399   Dali::Animation result;
61400
61401   arg1 = (Dali::Toolkit::Builder *)jarg1;
61402   if (!jarg2) {
61403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61404     return 0;
61405   }
61406   std::string arg2_str(jarg2);
61407   arg2 = &arg2_str;
61408   {
61409     try {
61410       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61411     } catch (std::out_of_range& e) {
61412       {
61413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61414       };
61415     } catch (std::exception& e) {
61416       {
61417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61418       };
61419     } catch (Dali::DaliException e) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61422       };
61423     } catch (...) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61426       };
61427     }
61428   }
61429
61430   jresult = new Dali::Animation((const Dali::Animation &)result);
61431
61432   //argout typemap for const std::string&
61433
61434   return jresult;
61435 }
61436
61437
61438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61439   void * jresult ;
61440   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61441   std::string *arg2 = 0 ;
61442   Dali::Property::Map *arg3 = 0 ;
61443   Dali::Animation result;
61444
61445   arg1 = (Dali::Toolkit::Builder *)jarg1;
61446   if (!jarg2) {
61447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61448     return 0;
61449   }
61450   std::string arg2_str(jarg2);
61451   arg2 = &arg2_str;
61452   arg3 = (Dali::Property::Map *)jarg3;
61453   if (!arg3) {
61454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61455     return 0;
61456   }
61457   {
61458     try {
61459       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61460     } catch (std::out_of_range& e) {
61461       {
61462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61463       };
61464     } catch (std::exception& e) {
61465       {
61466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (Dali::DaliException e) {
61469       {
61470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61471       };
61472     } catch (...) {
61473       {
61474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61475       };
61476     }
61477   }
61478
61479   jresult = new Dali::Animation((const Dali::Animation &)result);
61480
61481   //argout typemap for const std::string&
61482
61483   return jresult;
61484 }
61485
61486
61487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61488   void * jresult ;
61489   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61490   std::string *arg2 = 0 ;
61491   Dali::Actor arg3 ;
61492   Dali::Actor *argp3 ;
61493   Dali::Animation result;
61494
61495   arg1 = (Dali::Toolkit::Builder *)jarg1;
61496   if (!jarg2) {
61497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61498     return 0;
61499   }
61500   std::string arg2_str(jarg2);
61501   arg2 = &arg2_str;
61502   argp3 = (Dali::Actor *)jarg3;
61503   if (!argp3) {
61504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61505     return 0;
61506   }
61507   arg3 = *argp3;
61508   {
61509     try {
61510       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61511     } catch (std::out_of_range& e) {
61512       {
61513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (std::exception& e) {
61516       {
61517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (Dali::DaliException e) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61522       };
61523     } catch (...) {
61524       {
61525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61526       };
61527     }
61528   }
61529
61530   jresult = new Dali::Animation((const Dali::Animation &)result);
61531
61532   //argout typemap for const std::string&
61533
61534   return jresult;
61535 }
61536
61537
61538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61539   void * jresult ;
61540   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61541   std::string *arg2 = 0 ;
61542   Dali::Property::Map *arg3 = 0 ;
61543   Dali::Actor arg4 ;
61544   Dali::Actor *argp4 ;
61545   Dali::Animation result;
61546
61547   arg1 = (Dali::Toolkit::Builder *)jarg1;
61548   if (!jarg2) {
61549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61550     return 0;
61551   }
61552   std::string arg2_str(jarg2);
61553   arg2 = &arg2_str;
61554   arg3 = (Dali::Property::Map *)jarg3;
61555   if (!arg3) {
61556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61557     return 0;
61558   }
61559   argp4 = (Dali::Actor *)jarg4;
61560   if (!argp4) {
61561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61562     return 0;
61563   }
61564   arg4 = *argp4;
61565   {
61566     try {
61567       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61568     } catch (std::out_of_range& e) {
61569       {
61570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61571       };
61572     } catch (std::exception& e) {
61573       {
61574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61575       };
61576     } catch (Dali::DaliException e) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61579       };
61580     } catch (...) {
61581       {
61582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61583       };
61584     }
61585   }
61586
61587   jresult = new Dali::Animation((const Dali::Animation &)result);
61588
61589   //argout typemap for const std::string&
61590
61591   return jresult;
61592 }
61593
61594
61595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61596   void * jresult ;
61597   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61598   std::string *arg2 = 0 ;
61599   Dali::BaseHandle result;
61600
61601   arg1 = (Dali::Toolkit::Builder *)jarg1;
61602   if (!jarg2) {
61603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61604     return 0;
61605   }
61606   std::string arg2_str(jarg2);
61607   arg2 = &arg2_str;
61608   {
61609     try {
61610       result = (arg1)->Create((std::string const &)*arg2);
61611     } catch (std::out_of_range& e) {
61612       {
61613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61614       };
61615     } catch (std::exception& e) {
61616       {
61617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61618       };
61619     } catch (Dali::DaliException e) {
61620       {
61621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61622       };
61623     } catch (...) {
61624       {
61625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61626       };
61627     }
61628   }
61629
61630   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61631
61632   //argout typemap for const std::string&
61633
61634   return jresult;
61635 }
61636
61637
61638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61639   void * jresult ;
61640   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61641   std::string *arg2 = 0 ;
61642   Dali::Property::Map *arg3 = 0 ;
61643   Dali::BaseHandle result;
61644
61645   arg1 = (Dali::Toolkit::Builder *)jarg1;
61646   if (!jarg2) {
61647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61648     return 0;
61649   }
61650   std::string arg2_str(jarg2);
61651   arg2 = &arg2_str;
61652   arg3 = (Dali::Property::Map *)jarg3;
61653   if (!arg3) {
61654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61655     return 0;
61656   }
61657   {
61658     try {
61659       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61660     } catch (std::out_of_range& e) {
61661       {
61662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61663       };
61664     } catch (std::exception& e) {
61665       {
61666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (Dali::DaliException e) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61671       };
61672     } catch (...) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61675       };
61676     }
61677   }
61678
61679   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61680
61681   //argout typemap for const std::string&
61682
61683   return jresult;
61684 }
61685
61686
61687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61688   void * jresult ;
61689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61690   std::string *arg2 = 0 ;
61691   Dali::BaseHandle result;
61692
61693   arg1 = (Dali::Toolkit::Builder *)jarg1;
61694   if (!jarg2) {
61695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61696     return 0;
61697   }
61698   std::string arg2_str(jarg2);
61699   arg2 = &arg2_str;
61700   {
61701     try {
61702       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61703     } catch (std::out_of_range& e) {
61704       {
61705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61706       };
61707     } catch (std::exception& e) {
61708       {
61709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61710       };
61711     } catch (Dali::DaliException e) {
61712       {
61713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61714       };
61715     } catch (...) {
61716       {
61717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61718       };
61719     }
61720   }
61721
61722   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61723
61724   //argout typemap for const std::string&
61725
61726   return jresult;
61727 }
61728
61729
61730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61731   unsigned int jresult ;
61732   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61733   std::string *arg2 = 0 ;
61734   Dali::Handle *arg3 = 0 ;
61735   bool result;
61736
61737   arg1 = (Dali::Toolkit::Builder *)jarg1;
61738   if (!jarg2) {
61739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61740     return 0;
61741   }
61742   std::string arg2_str(jarg2);
61743   arg2 = &arg2_str;
61744   arg3 = (Dali::Handle *)jarg3;
61745   if (!arg3) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61747     return 0;
61748   }
61749   {
61750     try {
61751       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61752     } catch (std::out_of_range& e) {
61753       {
61754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61755       };
61756     } catch (std::exception& e) {
61757       {
61758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61759       };
61760     } catch (Dali::DaliException e) {
61761       {
61762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61763       };
61764     } catch (...) {
61765       {
61766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61767       };
61768     }
61769   }
61770
61771   jresult = result;
61772
61773   //argout typemap for const std::string&
61774
61775   return jresult;
61776 }
61777
61778
61779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61780   unsigned int jresult ;
61781   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61782   Dali::Handle *arg2 = 0 ;
61783   std::string *arg3 = 0 ;
61784   bool result;
61785
61786   arg1 = (Dali::Toolkit::Builder *)jarg1;
61787   arg2 = (Dali::Handle *)jarg2;
61788   if (!arg2) {
61789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61790     return 0;
61791   }
61792   if (!jarg3) {
61793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61794     return 0;
61795   }
61796   std::string arg3_str(jarg3);
61797   arg3 = &arg3_str;
61798   {
61799     try {
61800       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61801     } catch (std::out_of_range& e) {
61802       {
61803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61804       };
61805     } catch (std::exception& e) {
61806       {
61807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61808       };
61809     } catch (Dali::DaliException e) {
61810       {
61811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61812       };
61813     } catch (...) {
61814       {
61815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61816       };
61817     }
61818   }
61819
61820   jresult = result;
61821
61822   //argout typemap for const std::string&
61823
61824   return jresult;
61825 }
61826
61827
61828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61829   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61830   Dali::Actor arg2 ;
61831   Dali::Actor *argp2 ;
61832
61833   arg1 = (Dali::Toolkit::Builder *)jarg1;
61834   argp2 = (Dali::Actor *)jarg2;
61835   if (!argp2) {
61836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61837     return ;
61838   }
61839   arg2 = *argp2;
61840   {
61841     try {
61842       (arg1)->AddActors(arg2);
61843     } catch (std::out_of_range& e) {
61844       {
61845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61846       };
61847     } catch (std::exception& e) {
61848       {
61849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61850       };
61851     } catch (Dali::DaliException e) {
61852       {
61853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61854       };
61855     } catch (...) {
61856       {
61857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61858       };
61859     }
61860   }
61861
61862 }
61863
61864
61865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61866   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61867   std::string *arg2 = 0 ;
61868   Dali::Actor arg3 ;
61869   Dali::Actor *argp3 ;
61870
61871   arg1 = (Dali::Toolkit::Builder *)jarg1;
61872   if (!jarg2) {
61873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61874     return ;
61875   }
61876   std::string arg2_str(jarg2);
61877   arg2 = &arg2_str;
61878   argp3 = (Dali::Actor *)jarg3;
61879   if (!argp3) {
61880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61881     return ;
61882   }
61883   arg3 = *argp3;
61884   {
61885     try {
61886       (arg1)->AddActors((std::string const &)*arg2,arg3);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61902       };
61903     }
61904   }
61905
61906
61907   //argout typemap for const std::string&
61908
61909 }
61910
61911
61912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
61913   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61914   std::string *arg2 = 0 ;
61915
61916   arg1 = (Dali::Toolkit::Builder *)jarg1;
61917   if (!jarg2) {
61918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61919     return ;
61920   }
61921   std::string arg2_str(jarg2);
61922   arg2 = &arg2_str;
61923   {
61924     try {
61925       (arg1)->CreateRenderTask((std::string const &)*arg2);
61926     } catch (std::out_of_range& e) {
61927       {
61928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61929       };
61930     } catch (std::exception& e) {
61931       {
61932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61933       };
61934     } catch (Dali::DaliException e) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61937       };
61938     } catch (...) {
61939       {
61940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61941       };
61942     }
61943   }
61944
61945
61946   //argout typemap for const std::string&
61947
61948 }
61949
61950
61951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
61952   void * jresult ;
61953   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61954   std::string *arg2 = 0 ;
61955   Dali::FrameBufferImage result;
61956
61957   arg1 = (Dali::Toolkit::Builder *)jarg1;
61958   if (!jarg2) {
61959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61960     return 0;
61961   }
61962   std::string arg2_str(jarg2);
61963   arg2 = &arg2_str;
61964   {
61965     try {
61966       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
61967     } catch (std::out_of_range& e) {
61968       {
61969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61970       };
61971     } catch (std::exception& e) {
61972       {
61973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61974       };
61975     } catch (Dali::DaliException e) {
61976       {
61977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61978       };
61979     } catch (...) {
61980       {
61981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61982       };
61983     }
61984   }
61985
61986   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
61987
61988   //argout typemap for const std::string&
61989
61990   return jresult;
61991 }
61992
61993
61994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
61995   void * jresult ;
61996   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61997   std::string *arg2 = 0 ;
61998   Dali::Path result;
61999
62000   arg1 = (Dali::Toolkit::Builder *)jarg1;
62001   if (!jarg2) {
62002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62003     return 0;
62004   }
62005   std::string arg2_str(jarg2);
62006   arg2 = &arg2_str;
62007   {
62008     try {
62009       result = (arg1)->GetPath((std::string const &)*arg2);
62010     } catch (std::out_of_range& e) {
62011       {
62012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62013       };
62014     } catch (std::exception& e) {
62015       {
62016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62017       };
62018     } catch (Dali::DaliException e) {
62019       {
62020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62021       };
62022     } catch (...) {
62023       {
62024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62025       };
62026     }
62027   }
62028
62029   jresult = new Dali::Path((const Dali::Path &)result);
62030
62031   //argout typemap for const std::string&
62032
62033   return jresult;
62034 }
62035
62036
62037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62038   void * jresult ;
62039   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62040   std::string *arg2 = 0 ;
62041   Dali::PathConstrainer result;
62042
62043   arg1 = (Dali::Toolkit::Builder *)jarg1;
62044   if (!jarg2) {
62045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62046     return 0;
62047   }
62048   std::string arg2_str(jarg2);
62049   arg2 = &arg2_str;
62050   {
62051     try {
62052       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62053     } catch (std::out_of_range& e) {
62054       {
62055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62056       };
62057     } catch (std::exception& e) {
62058       {
62059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (Dali::DaliException e) {
62062       {
62063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62064       };
62065     } catch (...) {
62066       {
62067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62068       };
62069     }
62070   }
62071
62072   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62073
62074   //argout typemap for const std::string&
62075
62076   return jresult;
62077 }
62078
62079
62080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62081   void * jresult ;
62082   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62083   std::string *arg2 = 0 ;
62084   Dali::LinearConstrainer result;
62085
62086   arg1 = (Dali::Toolkit::Builder *)jarg1;
62087   if (!jarg2) {
62088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62089     return 0;
62090   }
62091   std::string arg2_str(jarg2);
62092   arg2 = &arg2_str;
62093   {
62094     try {
62095       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62096     } catch (std::out_of_range& e) {
62097       {
62098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62099       };
62100     } catch (std::exception& e) {
62101       {
62102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62103       };
62104     } catch (Dali::DaliException e) {
62105       {
62106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62107       };
62108     } catch (...) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62111       };
62112     }
62113   }
62114
62115   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62116
62117   //argout typemap for const std::string&
62118
62119   return jresult;
62120 }
62121
62122
62123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62124   void * jresult ;
62125   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62126   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62127
62128   arg1 = (Dali::Toolkit::Builder *)jarg1;
62129   {
62130     try {
62131       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62132     } catch (std::out_of_range& e) {
62133       {
62134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62135       };
62136     } catch (std::exception& e) {
62137       {
62138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62139       };
62140     } catch (Dali::DaliException e) {
62141       {
62142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62143       };
62144     } catch (...) {
62145       {
62146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62147       };
62148     }
62149   }
62150
62151   jresult = (void *)result;
62152   return jresult;
62153 }
62154
62155
62156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62157   void * jresult ;
62158   Dali::Toolkit::TransitionData *result = 0 ;
62159
62160   {
62161     try {
62162       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62163     } catch (std::out_of_range& e) {
62164       {
62165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62166       };
62167     } catch (std::exception& e) {
62168       {
62169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62170       };
62171     } catch (Dali::DaliException e) {
62172       {
62173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62174       };
62175     } catch (...) {
62176       {
62177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62178       };
62179     }
62180   }
62181
62182   jresult = (void *)result;
62183   return jresult;
62184 }
62185
62186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62187   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62188
62189   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62190   {
62191     try {
62192       delete arg1;
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62200       };
62201     } catch (Dali::DaliException e) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62204       };
62205     } catch (...) {
62206       {
62207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62208       };
62209     }
62210   }
62211
62212 }
62213
62214
62215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62216   void * jresult ;
62217   Dali::Property::Map *arg1 = 0 ;
62218   Dali::Toolkit::TransitionData result;
62219
62220   arg1 = (Dali::Property::Map *)jarg1;
62221   if (!arg1) {
62222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62223     return 0;
62224   }
62225   {
62226     try {
62227       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62228     } catch (std::out_of_range& e) {
62229       {
62230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62231       };
62232     } catch (std::exception& e) {
62233       {
62234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62235       };
62236     } catch (Dali::DaliException e) {
62237       {
62238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62239       };
62240     } catch (...) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62243       };
62244     }
62245   }
62246
62247   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62248   return jresult;
62249 }
62250
62251
62252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62253   void * jresult ;
62254   Dali::Property::Array *arg1 = 0 ;
62255   Dali::Toolkit::TransitionData result;
62256
62257   arg1 = (Dali::Property::Array *)jarg1;
62258   if (!arg1) {
62259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62260     return 0;
62261   }
62262   {
62263     try {
62264       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62265     } catch (std::out_of_range& e) {
62266       {
62267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62268       };
62269     } catch (std::exception& e) {
62270       {
62271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62272       };
62273     } catch (Dali::DaliException e) {
62274       {
62275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62276       };
62277     } catch (...) {
62278       {
62279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62280       };
62281     }
62282   }
62283
62284   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62285   return jresult;
62286 }
62287
62288
62289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62290   void * jresult ;
62291   Dali::BaseHandle arg1 ;
62292   Dali::BaseHandle *argp1 ;
62293   Dali::Toolkit::TransitionData result;
62294
62295   argp1 = (Dali::BaseHandle *)jarg1;
62296   if (!argp1) {
62297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62298     return 0;
62299   }
62300   arg1 = *argp1;
62301   {
62302     try {
62303       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (Dali::DaliException e) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62315       };
62316     } catch (...) {
62317       {
62318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62319       };
62320     }
62321   }
62322
62323   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62324   return jresult;
62325 }
62326
62327
62328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62329   void * jresult ;
62330   Dali::Toolkit::TransitionData *arg1 = 0 ;
62331   Dali::Toolkit::TransitionData *result = 0 ;
62332
62333   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62334   if (!arg1) {
62335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62336     return 0;
62337   }
62338   {
62339     try {
62340       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62341     } catch (std::out_of_range& e) {
62342       {
62343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62344       };
62345     } catch (std::exception& e) {
62346       {
62347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62348       };
62349     } catch (Dali::DaliException e) {
62350       {
62351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62352       };
62353     } catch (...) {
62354       {
62355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62356       };
62357     }
62358   }
62359
62360   jresult = (void *)result;
62361   return jresult;
62362 }
62363
62364
62365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62366   void * jresult ;
62367   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62368   Dali::Toolkit::TransitionData *arg2 = 0 ;
62369   Dali::Toolkit::TransitionData *result = 0 ;
62370
62371   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62372   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62373   if (!arg2) {
62374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62375     return 0;
62376   }
62377   {
62378     try {
62379       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62380     } catch (std::out_of_range& e) {
62381       {
62382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62383       };
62384     } catch (std::exception& e) {
62385       {
62386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62387       };
62388     } catch (Dali::DaliException e) {
62389       {
62390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62391       };
62392     } catch (...) {
62393       {
62394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62395       };
62396     }
62397   }
62398
62399   jresult = (void *)result;
62400   return jresult;
62401 }
62402
62403
62404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62405   unsigned long jresult ;
62406   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62407   size_t result;
62408
62409   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62410   {
62411     try {
62412       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62413     } catch (std::out_of_range& e) {
62414       {
62415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62416       };
62417     } catch (std::exception& e) {
62418       {
62419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62420       };
62421     } catch (Dali::DaliException e) {
62422       {
62423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62424       };
62425     } catch (...) {
62426       {
62427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62428       };
62429     }
62430   }
62431
62432   jresult = (unsigned long)result;
62433   return jresult;
62434 }
62435
62436
62437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62438   void * jresult ;
62439   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62440   size_t arg2 ;
62441   Dali::Property::Map result;
62442
62443   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62444   arg2 = (size_t)jarg2;
62445   {
62446     try {
62447       result = (arg1)->GetAnimatorAt(arg2);
62448     } catch (std::out_of_range& e) {
62449       {
62450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62451       };
62452     } catch (std::exception& e) {
62453       {
62454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62455       };
62456     } catch (Dali::DaliException e) {
62457       {
62458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62463       };
62464     }
62465   }
62466
62467   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62468   return jresult;
62469 }
62470
62471
62472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62473   int jresult ;
62474   int result;
62475
62476   {
62477     try {
62478       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62479     } catch (std::out_of_range& e) {
62480       {
62481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62482       };
62483     } catch (std::exception& e) {
62484       {
62485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62486       };
62487     } catch (Dali::DaliException e) {
62488       {
62489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62490       };
62491     } catch (...) {
62492       {
62493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62494       };
62495     }
62496   }
62497
62498   jresult = (int)result;
62499   return jresult;
62500 }
62501
62502
62503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62504   int jresult ;
62505   int result;
62506
62507   {
62508     try {
62509       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62510     } catch (std::out_of_range& e) {
62511       {
62512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62513       };
62514     } catch (std::exception& e) {
62515       {
62516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62517       };
62518     } catch (Dali::DaliException e) {
62519       {
62520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62521       };
62522     } catch (...) {
62523       {
62524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62525       };
62526     }
62527   }
62528
62529   jresult = (int)result;
62530   return jresult;
62531 }
62532
62533
62534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62535   int jresult ;
62536   int result;
62537
62538   {
62539     try {
62540       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62541     } catch (std::out_of_range& e) {
62542       {
62543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62544       };
62545     } catch (std::exception& e) {
62546       {
62547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62548       };
62549     } catch (Dali::DaliException e) {
62550       {
62551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62552       };
62553     } catch (...) {
62554       {
62555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62556       };
62557     }
62558   }
62559
62560   jresult = (int)result;
62561   return jresult;
62562 }
62563
62564
62565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62566   int jresult ;
62567   int result;
62568
62569   {
62570     try {
62571       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62572     } catch (std::out_of_range& e) {
62573       {
62574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (std::exception& e) {
62577       {
62578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62579       };
62580     } catch (Dali::DaliException e) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62583       };
62584     } catch (...) {
62585       {
62586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62587       };
62588     }
62589   }
62590
62591   jresult = (int)result;
62592   return jresult;
62593 }
62594
62595
62596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62597   int jresult ;
62598   int result;
62599
62600   {
62601     try {
62602       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62603     } catch (std::out_of_range& e) {
62604       {
62605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62606       };
62607     } catch (std::exception& e) {
62608       {
62609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62610       };
62611     } catch (Dali::DaliException e) {
62612       {
62613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62614       };
62615     } catch (...) {
62616       {
62617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62618       };
62619     }
62620   }
62621
62622   jresult = (int)result;
62623   return jresult;
62624 }
62625
62626
62627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62628   int jresult ;
62629   int result;
62630
62631   {
62632     try {
62633       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62634     } catch (std::out_of_range& e) {
62635       {
62636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62637       };
62638     } catch (std::exception& e) {
62639       {
62640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62641       };
62642     } catch (Dali::DaliException e) {
62643       {
62644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62645       };
62646     } catch (...) {
62647       {
62648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62649       };
62650     }
62651   }
62652
62653   jresult = (int)result;
62654   return jresult;
62655 }
62656
62657
62658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62659   int jresult ;
62660   int result;
62661
62662   {
62663     try {
62664       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62665     } catch (std::out_of_range& e) {
62666       {
62667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62668       };
62669     } catch (std::exception& e) {
62670       {
62671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62672       };
62673     } catch (Dali::DaliException e) {
62674       {
62675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62676       };
62677     } catch (...) {
62678       {
62679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62680       };
62681     }
62682   }
62683
62684   jresult = (int)result;
62685   return jresult;
62686 }
62687
62688
62689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62690   int jresult ;
62691   int result;
62692
62693   {
62694     try {
62695       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62696     } catch (std::out_of_range& e) {
62697       {
62698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62699       };
62700     } catch (std::exception& e) {
62701       {
62702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62703       };
62704     } catch (Dali::DaliException e) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62707       };
62708     } catch (...) {
62709       {
62710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62711       };
62712     }
62713   }
62714
62715   jresult = (int)result;
62716   return jresult;
62717 }
62718
62719
62720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62721   int jresult ;
62722   int result;
62723
62724   {
62725     try {
62726       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62727     } catch (std::out_of_range& e) {
62728       {
62729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62730       };
62731     } catch (std::exception& e) {
62732       {
62733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62734       };
62735     } catch (Dali::DaliException e) {
62736       {
62737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62738       };
62739     } catch (...) {
62740       {
62741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62742       };
62743     }
62744   }
62745
62746   jresult = (int)result;
62747   return jresult;
62748 }
62749
62750
62751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62752   int jresult ;
62753   int result;
62754
62755   {
62756     try {
62757       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62758     } catch (std::out_of_range& e) {
62759       {
62760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62761       };
62762     } catch (std::exception& e) {
62763       {
62764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62765       };
62766     } catch (Dali::DaliException e) {
62767       {
62768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62769       };
62770     } catch (...) {
62771       {
62772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62773       };
62774     }
62775   }
62776
62777   jresult = (int)result;
62778   return jresult;
62779 }
62780
62781
62782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62783   int jresult ;
62784   int result;
62785
62786   {
62787     try {
62788       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62789     } catch (std::out_of_range& e) {
62790       {
62791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62792       };
62793     } catch (std::exception& e) {
62794       {
62795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62796       };
62797     } catch (Dali::DaliException e) {
62798       {
62799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62800       };
62801     } catch (...) {
62802       {
62803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62804       };
62805     }
62806   }
62807
62808   jresult = (int)result;
62809   return jresult;
62810 }
62811
62812
62813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62814   int jresult ;
62815   int result;
62816
62817   {
62818     try {
62819       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62820     } catch (std::out_of_range& e) {
62821       {
62822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62823       };
62824     } catch (std::exception& e) {
62825       {
62826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (Dali::DaliException e) {
62829       {
62830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62831       };
62832     } catch (...) {
62833       {
62834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62835       };
62836     }
62837   }
62838
62839   jresult = (int)result;
62840   return jresult;
62841 }
62842
62843
62844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62845   int jresult ;
62846   int result;
62847
62848   {
62849     try {
62850       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62851     } catch (std::out_of_range& e) {
62852       {
62853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62854       };
62855     } catch (std::exception& e) {
62856       {
62857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62858       };
62859     } catch (Dali::DaliException e) {
62860       {
62861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62862       };
62863     } catch (...) {
62864       {
62865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62866       };
62867     }
62868   }
62869
62870   jresult = (int)result;
62871   return jresult;
62872 }
62873
62874
62875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62876   int jresult ;
62877   int result;
62878
62879   {
62880     try {
62881       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62882     } catch (std::out_of_range& e) {
62883       {
62884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62885       };
62886     } catch (std::exception& e) {
62887       {
62888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62889       };
62890     } catch (Dali::DaliException e) {
62891       {
62892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62893       };
62894     } catch (...) {
62895       {
62896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62897       };
62898     }
62899   }
62900
62901   jresult = (int)result;
62902   return jresult;
62903 }
62904
62905
62906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62907   void * jresult ;
62908   Dali::Toolkit::Control result;
62909
62910   {
62911     try {
62912       result = Dali::Toolkit::Internal::Control::New();
62913     } catch (std::out_of_range& e) {
62914       {
62915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62916       };
62917     } catch (std::exception& e) {
62918       {
62919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62920       };
62921     } catch (Dali::DaliException e) {
62922       {
62923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62924       };
62925     } catch (...) {
62926       {
62927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62928       };
62929     }
62930   }
62931
62932   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62933   return jresult;
62934 }
62935
62936
62937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62939   std::string *arg2 = 0 ;
62940
62941   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62942   if (!jarg2) {
62943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62944     return ;
62945   }
62946   std::string arg2_str(jarg2);
62947   arg2 = &arg2_str;
62948   {
62949     try {
62950       (arg1)->SetStyleName((std::string const &)*arg2);
62951     } catch (std::out_of_range& e) {
62952       {
62953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62954       };
62955     } catch (std::exception& e) {
62956       {
62957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62958       };
62959     } catch (Dali::DaliException e) {
62960       {
62961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62966       };
62967     }
62968   }
62969
62970
62971   //argout typemap for const std::string&
62972
62973 }
62974
62975
62976 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
62977   char * jresult ;
62978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62979   std::string *result = 0 ;
62980
62981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62982   {
62983     try {
62984       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
62985     } catch (std::out_of_range& e) {
62986       {
62987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62988       };
62989     } catch (std::exception& e) {
62990       {
62991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62992       };
62993     } catch (Dali::DaliException e) {
62994       {
62995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62996       };
62997     } catch (...) {
62998       {
62999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63000       };
63001     }
63002   }
63003
63004   jresult = SWIG_csharp_string_callback(result->c_str());
63005   return jresult;
63006 }
63007
63008
63009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63011   Dali::Vector4 *arg2 = 0 ;
63012
63013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63014   arg2 = (Dali::Vector4 *)jarg2;
63015   if (!arg2) {
63016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63017     return ;
63018   }
63019   {
63020     try {
63021       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63022     } catch (std::out_of_range& e) {
63023       {
63024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63025       };
63026     } catch (std::exception& e) {
63027       {
63028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63029       };
63030     } catch (Dali::DaliException e) {
63031       {
63032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63033       };
63034     } catch (...) {
63035       {
63036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63037       };
63038     }
63039   }
63040
63041 }
63042
63043
63044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63045   void * jresult ;
63046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63047   Dali::Vector4 result;
63048
63049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63050   {
63051     try {
63052       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63053     } catch (std::out_of_range& e) {
63054       {
63055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63056       };
63057     } catch (std::exception& e) {
63058       {
63059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63060       };
63061     } catch (Dali::DaliException e) {
63062       {
63063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63064       };
63065     } catch (...) {
63066       {
63067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63068       };
63069     }
63070   }
63071
63072   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63073   return jresult;
63074 }
63075
63076
63077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63079   Dali::Image arg2 ;
63080   Dali::Image *argp2 ;
63081
63082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63083   argp2 = (Dali::Image *)jarg2;
63084   if (!argp2) {
63085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63086     return ;
63087   }
63088   arg2 = *argp2;
63089   {
63090     try {
63091       (arg1)->SetBackgroundImage(arg2);
63092     } catch (std::out_of_range& e) {
63093       {
63094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63095       };
63096     } catch (std::exception& e) {
63097       {
63098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63099       };
63100     } catch (Dali::DaliException e) {
63101       {
63102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63103       };
63104     } catch (...) {
63105       {
63106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63107       };
63108     }
63109   }
63110
63111 }
63112
63113
63114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63116   Dali::Property::Map *arg2 = 0 ;
63117
63118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63119   arg2 = (Dali::Property::Map *)jarg2;
63120   if (!arg2) {
63121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63122     return ;
63123   }
63124   {
63125     try {
63126       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63127     } catch (std::out_of_range& e) {
63128       {
63129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63130       };
63131     } catch (std::exception& e) {
63132       {
63133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63134       };
63135     } catch (Dali::DaliException e) {
63136       {
63137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63138       };
63139     } catch (...) {
63140       {
63141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63142       };
63143     }
63144   }
63145
63146 }
63147
63148
63149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63151
63152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63153   {
63154     try {
63155       (arg1)->ClearBackground();
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63163       };
63164     } catch (Dali::DaliException e) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63167       };
63168     } catch (...) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63171       };
63172     }
63173   }
63174
63175 }
63176
63177
63178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63180   Dali::Gesture::Type arg2 ;
63181
63182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63183   arg2 = (Dali::Gesture::Type)jarg2;
63184   {
63185     try {
63186       (arg1)->EnableGestureDetection(arg2);
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63194       };
63195     } catch (Dali::DaliException e) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63202       };
63203     }
63204   }
63205
63206 }
63207
63208
63209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63211   Dali::Gesture::Type arg2 ;
63212
63213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63214   arg2 = (Dali::Gesture::Type)jarg2;
63215   {
63216     try {
63217       (arg1)->DisableGestureDetection(arg2);
63218     } catch (std::out_of_range& e) {
63219       {
63220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63221       };
63222     } catch (std::exception& e) {
63223       {
63224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63225       };
63226     } catch (Dali::DaliException e) {
63227       {
63228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63229       };
63230     } catch (...) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63233       };
63234     }
63235   }
63236
63237 }
63238
63239
63240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63241   void * jresult ;
63242   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63243   Dali::PinchGestureDetector result;
63244
63245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63246   {
63247     try {
63248       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63249     } catch (std::out_of_range& e) {
63250       {
63251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63252       };
63253     } catch (std::exception& e) {
63254       {
63255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63256       };
63257     } catch (Dali::DaliException e) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63260       };
63261     } catch (...) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63264       };
63265     }
63266   }
63267
63268   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63269   return jresult;
63270 }
63271
63272
63273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63274   void * jresult ;
63275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63276   Dali::PanGestureDetector result;
63277
63278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63279   {
63280     try {
63281       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63282     } catch (std::out_of_range& e) {
63283       {
63284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63285       };
63286     } catch (std::exception& e) {
63287       {
63288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63289       };
63290     } catch (Dali::DaliException e) {
63291       {
63292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63293       };
63294     } catch (...) {
63295       {
63296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63297       };
63298     }
63299   }
63300
63301   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63302   return jresult;
63303 }
63304
63305
63306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63307   void * jresult ;
63308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63309   Dali::TapGestureDetector result;
63310
63311   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63312   {
63313     try {
63314       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63315     } catch (std::out_of_range& e) {
63316       {
63317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63318       };
63319     } catch (std::exception& e) {
63320       {
63321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63322       };
63323     } catch (Dali::DaliException e) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63326       };
63327     } catch (...) {
63328       {
63329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63330       };
63331     }
63332   }
63333
63334   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63335   return jresult;
63336 }
63337
63338
63339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63340   void * jresult ;
63341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63342   Dali::LongPressGestureDetector result;
63343
63344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63345   {
63346     try {
63347       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63348     } catch (std::out_of_range& e) {
63349       {
63350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (std::exception& e) {
63353       {
63354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63355       };
63356     } catch (Dali::DaliException e) {
63357       {
63358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63359       };
63360     } catch (...) {
63361       {
63362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63363       };
63364     }
63365   }
63366
63367   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63368   return jresult;
63369 }
63370
63371
63372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63374   bool arg2 ;
63375
63376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63377   arg2 = jarg2 ? true : false;
63378   {
63379     try {
63380       (arg1)->SetKeyboardNavigationSupport(arg2);
63381     } catch (std::out_of_range& e) {
63382       {
63383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63384       };
63385     } catch (std::exception& e) {
63386       {
63387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63388       };
63389     } catch (Dali::DaliException e) {
63390       {
63391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63392       };
63393     } catch (...) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63396       };
63397     }
63398   }
63399
63400 }
63401
63402
63403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63404   unsigned int jresult ;
63405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63406   bool result;
63407
63408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63409   {
63410     try {
63411       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63412     } catch (std::out_of_range& e) {
63413       {
63414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63415       };
63416     } catch (std::exception& e) {
63417       {
63418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63419       };
63420     } catch (Dali::DaliException e) {
63421       {
63422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63423       };
63424     } catch (...) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63427       };
63428     }
63429   }
63430
63431   jresult = result;
63432   return jresult;
63433 }
63434
63435
63436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63438
63439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63440   {
63441     try {
63442       (arg1)->SetKeyInputFocus();
63443     } catch (std::out_of_range& e) {
63444       {
63445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63446       };
63447     } catch (std::exception& e) {
63448       {
63449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63450       };
63451     } catch (Dali::DaliException e) {
63452       {
63453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63454       };
63455     } catch (...) {
63456       {
63457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63458       };
63459     }
63460   }
63461
63462 }
63463
63464
63465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63466   unsigned int jresult ;
63467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63468   bool result;
63469
63470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63471   {
63472     try {
63473       result = (bool)(arg1)->HasKeyInputFocus();
63474     } catch (std::out_of_range& e) {
63475       {
63476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63477       };
63478     } catch (std::exception& e) {
63479       {
63480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63481       };
63482     } catch (Dali::DaliException e) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63485       };
63486     } catch (...) {
63487       {
63488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63489       };
63490     }
63491   }
63492
63493   jresult = result;
63494   return jresult;
63495 }
63496
63497
63498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63500
63501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63502   {
63503     try {
63504       (arg1)->ClearKeyInputFocus();
63505     } catch (std::out_of_range& e) {
63506       {
63507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63508       };
63509     } catch (std::exception& e) {
63510       {
63511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63512       };
63513     } catch (Dali::DaliException e) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63520       };
63521     }
63522   }
63523
63524 }
63525
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63529   bool arg2 ;
63530
63531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63532   arg2 = jarg2 ? true : false;
63533   {
63534     try {
63535       (arg1)->SetAsKeyboardFocusGroup(arg2);
63536     } catch (std::out_of_range& e) {
63537       {
63538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63539       };
63540     } catch (std::exception& e) {
63541       {
63542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (Dali::DaliException e) {
63545       {
63546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63547       };
63548     } catch (...) {
63549       {
63550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63551       };
63552     }
63553   }
63554
63555 }
63556
63557
63558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63559   unsigned int jresult ;
63560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63561   bool result;
63562
63563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63564   {
63565     try {
63566       result = (bool)(arg1)->IsKeyboardFocusGroup();
63567     } catch (std::out_of_range& e) {
63568       {
63569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (std::exception& e) {
63572       {
63573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (Dali::DaliException e) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585
63586   jresult = result;
63587   return jresult;
63588 }
63589
63590
63591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63592   void * jresult ;
63593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63594   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63595
63596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63597   {
63598     try {
63599       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63600     } catch (std::out_of_range& e) {
63601       {
63602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63603       };
63604     } catch (std::exception& e) {
63605       {
63606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63607       };
63608     } catch (Dali::DaliException e) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63611       };
63612     } catch (...) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63615       };
63616     }
63617   }
63618
63619   jresult = (void *)result;
63620   return jresult;
63621 }
63622
63623
63624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63625   void * jresult ;
63626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63627   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63628
63629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63630   {
63631     try {
63632       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63633     } catch (std::out_of_range& e) {
63634       {
63635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (std::exception& e) {
63638       {
63639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63640       };
63641     } catch (Dali::DaliException e) {
63642       {
63643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63648       };
63649     }
63650   }
63651
63652   jresult = (void *)result;
63653   return jresult;
63654 }
63655
63656
63657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63658   void * jresult ;
63659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63660   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63661
63662   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63663   {
63664     try {
63665       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63666     } catch (std::out_of_range& e) {
63667       {
63668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63669       };
63670     } catch (std::exception& e) {
63671       {
63672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63673       };
63674     } catch (Dali::DaliException e) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63677       };
63678     } catch (...) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63681       };
63682     }
63683   }
63684
63685   jresult = (void *)result;
63686   return jresult;
63687 }
63688
63689
63690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63691   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63692   int arg2 ;
63693   SwigDirector_ViewImpl *darg = 0;
63694
63695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63696   arg2 = (int)jarg2;
63697   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63698   if(!darg) {
63699     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63700     return;
63701   }
63702   {
63703     try {
63704       if(darg) {
63705         (darg)->OnStageConnection(arg2);
63706       }
63707     } catch (std::out_of_range& e) {
63708       {
63709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63710       };
63711     } catch (std::exception& e) {
63712       {
63713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63714       };
63715     } catch (Dali::DaliException e) {
63716       {
63717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63718       };
63719     } catch (...) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63722       };
63723     }
63724   }
63725
63726 }
63727
63728
63729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63731   int arg2 ;
63732   SwigDirector_ViewImpl *darg = 0;
63733
63734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63735   arg2 = (int)jarg2;
63736   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63737   if(!darg) {
63738     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63739     return;
63740   }
63741   {
63742     try {
63743       if(darg) {
63744         (darg)->OnStageConnectionSwigPublic(arg2);
63745       }
63746     } catch (std::out_of_range& e) {
63747       {
63748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63749       };
63750     } catch (std::exception& e) {
63751       {
63752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63753       };
63754     } catch (Dali::DaliException e) {
63755       {
63756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63757       };
63758     } catch (...) {
63759       {
63760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63761       };
63762     }
63763   }
63764
63765 }
63766
63767
63768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63770   SwigDirector_ViewImpl *darg = 0;
63771
63772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63773   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63774   if(!darg) {
63775     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63776     return;
63777   }
63778   {
63779     try {
63780       if(darg) {
63781         (darg)->OnStageDisconnection();
63782       }
63783     } catch (std::out_of_range& e) {
63784       {
63785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63786       };
63787     } catch (std::exception& e) {
63788       {
63789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63790       };
63791     } catch (Dali::DaliException e) {
63792       {
63793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63794       };
63795     } catch (...) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63798       };
63799     }
63800   }
63801
63802 }
63803
63804
63805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63807   SwigDirector_ViewImpl *darg = 0;
63808
63809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63810   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63811   if(!darg) {
63812     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63813     return;
63814   }
63815   {
63816     try {
63817       if(darg) {
63818         (darg)->OnStageDisconnectionSwigPublic();
63819       }
63820     } catch (std::out_of_range& e) {
63821       {
63822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63823       };
63824     } catch (std::exception& e) {
63825       {
63826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63827       };
63828     } catch (Dali::DaliException e) {
63829       {
63830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63831       };
63832     } catch (...) {
63833       {
63834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63835       };
63836     }
63837   }
63838
63839 }
63840
63841
63842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63844   Dali::Actor *arg2 = 0 ;
63845   SwigDirector_ViewImpl *darg = 0;
63846
63847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63848   arg2 = (Dali::Actor *)jarg2;
63849   if (!arg2) {
63850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63851     return ;
63852   }
63853   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63854   if(!darg) {
63855     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63856     return;
63857   }
63858   {
63859     try {
63860       if(darg) {
63861         (darg)->OnChildAdd(*arg2);
63862       }
63863     } catch (std::out_of_range& e) {
63864       {
63865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63866       };
63867     } catch (std::exception& e) {
63868       {
63869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63870       };
63871     } catch (Dali::DaliException e) {
63872       {
63873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63874       };
63875     } catch (...) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63878       };
63879     }
63880   }
63881
63882 }
63883
63884
63885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63887   Dali::Actor *arg2 = 0 ;
63888   SwigDirector_ViewImpl *darg = 0;
63889
63890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63891   arg2 = (Dali::Actor *)jarg2;
63892   if (!arg2) {
63893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63894     return ;
63895   }
63896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63897   if(!darg) {
63898     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63899     return;
63900   }
63901   {
63902     try {
63903       if(darg) {
63904           (darg)->OnChildAddSwigPublic(*arg2);
63905       }
63906     } catch (std::out_of_range& e) {
63907       {
63908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63909       };
63910     } catch (std::exception& e) {
63911       {
63912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63913       };
63914     } catch (Dali::DaliException e) {
63915       {
63916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63917       };
63918     } catch (...) {
63919       {
63920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63921       };
63922     }
63923   }
63924
63925 }
63926
63927
63928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63929   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63930   Dali::Actor *arg2 = 0 ;
63931   SwigDirector_ViewImpl *darg = 0;
63932
63933   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63934   arg2 = (Dali::Actor *)jarg2;
63935   if (!arg2) {
63936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63937     return ;
63938   }
63939   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63940   if(!darg) {
63941     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63942     return;
63943   }
63944   {
63945     try {
63946       if(darg) {
63947         (darg)->OnChildRemove(*arg2);
63948       }
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63956       };
63957     } catch (Dali::DaliException e) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63960       };
63961     } catch (...) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63964       };
63965     }
63966   }
63967
63968 }
63969
63970
63971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63973   Dali::Actor *arg2 = 0 ;
63974   SwigDirector_ViewImpl *darg = 0;
63975
63976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63977   arg2 = (Dali::Actor *)jarg2;
63978   if (!arg2) {
63979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63980     return ;
63981   }
63982   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63983   if(!darg) {
63984     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63985     return;
63986   }
63987   {
63988     try {
63989       if(darg) {
63990         (darg)->OnChildRemoveSwigPublic(*arg2);
63991       }
63992     } catch (std::out_of_range& e) {
63993       {
63994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63995       };
63996     } catch (std::exception& e) {
63997       {
63998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63999       };
64000     } catch (Dali::DaliException e) {
64001       {
64002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64003       };
64004     } catch (...) {
64005       {
64006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64007       };
64008     }
64009   }
64010
64011 }
64012
64013
64014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64016   Dali::Property::Index arg2 ;
64017   Dali::Property::Value arg3 ;
64018   Dali::Property::Value *argp3 ;
64019   SwigDirector_ViewImpl *darg = 0;
64020
64021   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64022   arg2 = (Dali::Property::Index)jarg2;
64023   argp3 = (Dali::Property::Value *)jarg3;
64024   if (!argp3) {
64025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64026     return ;
64027   }
64028   arg3 = *argp3;
64029   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64030   if (!darg) {
64031     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64032     return;
64033   }
64034   {
64035     try {
64036       (darg)->OnPropertySet(arg2,arg3);
64037     } catch (std::out_of_range& e) {
64038       {
64039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64040       };
64041     } catch (std::exception& e) {
64042       {
64043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64044       };
64045     } catch (Dali::DaliException e) {
64046       {
64047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64048       };
64049     } catch (...) {
64050       {
64051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64052       };
64053     }
64054   }
64055
64056 }
64057
64058
64059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64061   Dali::Property::Index arg2 ;
64062   Dali::Property::Value arg3 ;
64063   Dali::Property::Value *argp3 ;
64064   SwigDirector_ViewImpl *darg = 0;
64065
64066   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64067   arg2 = (Dali::Property::Index)jarg2;
64068   argp3 = (Dali::Property::Value *)jarg3;
64069   if (!argp3) {
64070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64071     return ;
64072   }
64073   arg3 = *argp3;
64074   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64075   if (!darg) {
64076     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64077     return;
64078   }
64079   {
64080     try {
64081       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64082     } catch (std::out_of_range& e) {
64083       {
64084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64085       };
64086     } catch (std::exception& e) {
64087       {
64088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64089       };
64090     } catch (Dali::DaliException e) {
64091       {
64092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64093       };
64094     } catch (...) {
64095       {
64096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64097       };
64098     }
64099   }
64100
64101 }
64102
64103
64104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64106   Dali::Vector3 *arg2 = 0 ;
64107   SwigDirector_ViewImpl *darg = 0;
64108
64109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64110   arg2 = (Dali::Vector3 *)jarg2;
64111   if (!arg2) {
64112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64113     return ;
64114   }
64115   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64116   if (!darg) {
64117     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64118     return;
64119   }
64120   {
64121     try {
64122       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64130       };
64131     } catch (Dali::DaliException e) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64138       };
64139     }
64140   }
64141
64142 }
64143
64144
64145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64147   Dali::Vector3 *arg2 = 0 ;
64148   SwigDirector_ViewImpl *darg = 0;
64149
64150   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64151   arg2 = (Dali::Vector3 *)jarg2;
64152   if (!arg2) {
64153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64154     return ;
64155   }
64156   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64157   if (!darg) {
64158     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64159     return;
64160   }
64161   {
64162     try {
64163       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64164     } catch (std::out_of_range& e) {
64165       {
64166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64167       };
64168     } catch (std::exception& e) {
64169       {
64170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64171       };
64172     } catch (Dali::DaliException e) {
64173       {
64174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64175       };
64176     } catch (...) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64179       };
64180     }
64181   }
64182
64183 }
64184
64185
64186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64187   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64188   Dali::Animation *arg2 = 0 ;
64189   Dali::Vector3 *arg3 = 0 ;
64190   SwigDirector_ViewImpl *darg = 0;
64191
64192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64193   arg2 = (Dali::Animation *)jarg2;
64194   if (!arg2) {
64195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64196     return ;
64197   }
64198   arg3 = (Dali::Vector3 *)jarg3;
64199   if (!arg3) {
64200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64201     return ;
64202   }
64203   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64204   if (!darg) {
64205     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64206     return;
64207   }
64208   {
64209     try {
64210       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64211     } catch (std::out_of_range& e) {
64212       {
64213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64214       };
64215     } catch (std::exception& e) {
64216       {
64217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64218       };
64219     } catch (Dali::DaliException e) {
64220       {
64221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64222       };
64223     } catch (...) {
64224       {
64225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64226       };
64227     }
64228   }
64229
64230 }
64231
64232
64233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64235   Dali::Animation *arg2 = 0 ;
64236   Dali::Vector3 *arg3 = 0 ;
64237   SwigDirector_ViewImpl *darg = 0;
64238
64239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64240   arg2 = (Dali::Animation *)jarg2;
64241   if (!arg2) {
64242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64243     return ;
64244   }
64245   arg3 = (Dali::Vector3 *)jarg3;
64246   if (!arg3) {
64247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64248     return ;
64249   }
64250   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64251   if (!darg) {
64252     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64253     return;
64254   }
64255   {
64256     try {
64257       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64258     } catch (std::out_of_range& e) {
64259       {
64260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64261       };
64262     } catch (std::exception& e) {
64263       {
64264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64265       };
64266     } catch (Dali::DaliException e) {
64267       {
64268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64269       };
64270     } catch (...) {
64271       {
64272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64273       };
64274     }
64275   }
64276
64277 }
64278
64279
64280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64281   unsigned int jresult ;
64282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64283   Dali::TouchEvent *arg2 = 0 ;
64284   SwigDirector_ViewImpl *darg = 0;
64285   bool result;
64286
64287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64288   arg2 = (Dali::TouchEvent *)jarg2;
64289   if (!arg2) {
64290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64291     return 0;
64292   }
64293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64294   if (!darg) {
64295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64296     return 0;
64297   }
64298   {
64299     try {
64300       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64301     } catch (std::out_of_range& e) {
64302       {
64303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64304       };
64305     } catch (std::exception& e) {
64306       {
64307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64308       };
64309     } catch (Dali::DaliException e) {
64310       {
64311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64312       };
64313     } catch (...) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64316       };
64317     }
64318   }
64319
64320   jresult = result;
64321   return jresult;
64322 }
64323
64324
64325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64326   unsigned int jresult ;
64327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64328   Dali::TouchEvent *arg2 = 0 ;
64329   SwigDirector_ViewImpl *darg = 0;
64330   bool result;
64331
64332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64333   arg2 = (Dali::TouchEvent *)jarg2;
64334   if (!arg2) {
64335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64336     return 0;
64337   }
64338   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64339   if (!darg) {
64340     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64341     return 0;
64342   }
64343   {
64344     try {
64345       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64346     } catch (std::out_of_range& e) {
64347       {
64348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64349       };
64350     } catch (std::exception& e) {
64351       {
64352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64353       };
64354     } catch (Dali::DaliException e) {
64355       {
64356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64357       };
64358     } catch (...) {
64359       {
64360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64361       };
64362     }
64363   }
64364
64365   jresult = result;
64366   return jresult;
64367 }
64368
64369
64370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64371   unsigned int jresult ;
64372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64373   Dali::HoverEvent *arg2 = 0 ;
64374   SwigDirector_ViewImpl *darg = 0;
64375   bool result;
64376
64377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64378   arg2 = (Dali::HoverEvent *)jarg2;
64379   if (!arg2) {
64380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64381     return 0;
64382   }
64383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64384   if (!darg) {
64385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64386     return 0;
64387   }
64388   {
64389     try {
64390       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64391     } catch (std::out_of_range& e) {
64392       {
64393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64394       };
64395     } catch (std::exception& e) {
64396       {
64397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64398       };
64399     } catch (Dali::DaliException e) {
64400       {
64401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64402       };
64403     } catch (...) {
64404       {
64405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64406       };
64407     }
64408   }
64409
64410   jresult = result;
64411   return jresult;
64412 }
64413
64414
64415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64416   unsigned int jresult ;
64417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64418   Dali::HoverEvent *arg2 = 0 ;
64419   SwigDirector_ViewImpl *darg = 0;
64420   bool result;
64421
64422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64423   arg2 = (Dali::HoverEvent *)jarg2;
64424   if (!arg2) {
64425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64426     return 0;
64427   }
64428   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64429   if (!darg) {
64430     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64431     return 0;
64432   }
64433   {
64434     try {
64435       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64436     } catch (std::out_of_range& e) {
64437       {
64438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64439       };
64440     } catch (std::exception& e) {
64441       {
64442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64443       };
64444     } catch (Dali::DaliException e) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64447       };
64448     } catch (...) {
64449       {
64450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64451       };
64452     }
64453   }
64454
64455   jresult = result;
64456   return jresult;
64457 }
64458
64459
64460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64461   unsigned int jresult ;
64462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64463   Dali::KeyEvent *arg2 = 0 ;
64464   SwigDirector_ViewImpl *darg = 0;
64465   bool result;
64466
64467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64468   arg2 = (Dali::KeyEvent *)jarg2;
64469   if (!arg2) {
64470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64471     return 0;
64472   }
64473   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64474   if (!darg) {
64475     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64476     return 0;
64477   }
64478   {
64479     try {
64480       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64481     } catch (std::out_of_range& e) {
64482       {
64483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (std::exception& e) {
64486       {
64487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64488       };
64489     } catch (Dali::DaliException e) {
64490       {
64491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64492       };
64493     } catch (...) {
64494       {
64495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64496       };
64497     }
64498   }
64499
64500   jresult = result;
64501   return jresult;
64502 }
64503
64504
64505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64506   unsigned int jresult ;
64507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64508   Dali::KeyEvent *arg2 = 0 ;
64509   SwigDirector_ViewImpl *darg = 0;
64510   bool result;
64511
64512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64513   arg2 = (Dali::KeyEvent *)jarg2;
64514   if (!arg2) {
64515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64516     return 0;
64517   }
64518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64519   if (!darg) {
64520     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64521     return 0;
64522   }
64523   {
64524     try {
64525       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64526     } catch (std::out_of_range& e) {
64527       {
64528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64529       };
64530     } catch (std::exception& e) {
64531       {
64532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64533       };
64534     } catch (Dali::DaliException e) {
64535       {
64536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64537       };
64538     } catch (...) {
64539       {
64540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64541       };
64542     }
64543   }
64544
64545   jresult = result;
64546   return jresult;
64547 }
64548
64549
64550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64551   unsigned int jresult ;
64552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64553   Dali::WheelEvent *arg2 = 0 ;
64554   SwigDirector_ViewImpl *darg = 0;
64555   bool result;
64556
64557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64558   arg2 = (Dali::WheelEvent *)jarg2;
64559   if (!arg2) {
64560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64561     return 0;
64562   }
64563   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64564   if (!darg) {
64565     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64566     return 0;
64567   }
64568   {
64569     try {
64570       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64571     } catch (std::out_of_range& e) {
64572       {
64573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64574       };
64575     } catch (std::exception& e) {
64576       {
64577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64578       };
64579     } catch (Dali::DaliException e) {
64580       {
64581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64582       };
64583     } catch (...) {
64584       {
64585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64586       };
64587     }
64588   }
64589
64590   jresult = result;
64591   return jresult;
64592 }
64593
64594
64595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64596   unsigned int jresult ;
64597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64598   Dali::WheelEvent *arg2 = 0 ;
64599   SwigDirector_ViewImpl *darg = 0;
64600   bool result;
64601
64602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64603   arg2 = (Dali::WheelEvent *)jarg2;
64604   if (!arg2) {
64605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64606     return 0;
64607   }
64608   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64609   if (!darg) {
64610     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64611     return 0;
64612   }
64613   {
64614     try {
64615       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64616     } catch (std::out_of_range& e) {
64617       {
64618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64619       };
64620     } catch (std::exception& e) {
64621       {
64622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (Dali::DaliException e) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64631       };
64632     }
64633   }
64634
64635   jresult = result;
64636   return jresult;
64637 }
64638
64639
64640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64642   Dali::Vector2 *arg2 = 0 ;
64643   Dali::RelayoutContainer *arg3 = 0 ;
64644   SwigDirector_ViewImpl *darg = 0;
64645
64646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64647   arg2 = (Dali::Vector2 *)jarg2;
64648   if (!arg2) {
64649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64650     return ;
64651   }
64652   arg3 = (Dali::RelayoutContainer *)jarg3;
64653   if (!arg3) {
64654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64655     return ;
64656   }
64657   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64658   if (!darg) {
64659     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64660     return;
64661   }
64662   {
64663     try {
64664       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64665     } catch (std::out_of_range& e) {
64666       {
64667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64668       };
64669     } catch (std::exception& e) {
64670       {
64671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64672       };
64673     } catch (Dali::DaliException e) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64676       };
64677     } catch (...) {
64678       {
64679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64680       };
64681     }
64682   }
64683
64684 }
64685
64686
64687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64688   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64689   Dali::Vector2 *arg2 = 0 ;
64690   Dali::RelayoutContainer *arg3 = 0 ;
64691   SwigDirector_ViewImpl *darg = 0;
64692
64693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64694   arg2 = (Dali::Vector2 *)jarg2;
64695   if (!arg2) {
64696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64697     return ;
64698   }
64699   arg3 = (Dali::RelayoutContainer *)jarg3;
64700   if (!arg3) {
64701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64702     return ;
64703   }
64704   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64705   if (!darg) {
64706     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64707     return;
64708   }
64709   {
64710     try {
64711       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64712     } catch (std::out_of_range& e) {
64713       {
64714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64715       };
64716     } catch (std::exception& e) {
64717       {
64718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64719       };
64720     } catch (Dali::DaliException e) {
64721       {
64722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64723       };
64724     } catch (...) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64727       };
64728     }
64729   }
64730
64731 }
64732
64733
64734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64736   Dali::ResizePolicy::Type arg2 ;
64737   Dali::Dimension::Type arg3 ;
64738   SwigDirector_ViewImpl *darg = 0;
64739
64740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64741   arg2 = (Dali::ResizePolicy::Type)jarg2;
64742   arg3 = (Dali::Dimension::Type)jarg3;
64743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64744   if (!darg) {
64745     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64746     return;
64747   }
64748   {
64749     try {
64750       (darg)->OnSetResizePolicy(arg2,arg3);
64751     } catch (std::out_of_range& e) {
64752       {
64753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64754       };
64755     } catch (std::exception& e) {
64756       {
64757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64758       };
64759     } catch (Dali::DaliException e) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64762       };
64763     } catch (...) {
64764       {
64765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64766       };
64767     }
64768   }
64769
64770 }
64771
64772
64773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64775   Dali::ResizePolicy::Type arg2 ;
64776   Dali::Dimension::Type arg3 ;
64777   SwigDirector_ViewImpl *darg = 0;
64778
64779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64780   arg2 = (Dali::ResizePolicy::Type)jarg2;
64781   arg3 = (Dali::Dimension::Type)jarg3;
64782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64783   if (!darg) {
64784     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64785     return;
64786   }
64787   {
64788     try {
64789       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64790     } catch (std::out_of_range& e) {
64791       {
64792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64793       };
64794     } catch (std::exception& e) {
64795       {
64796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64797       };
64798     } catch (Dali::DaliException e) {
64799       {
64800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64801       };
64802     } catch (...) {
64803       {
64804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64805       };
64806     }
64807   }
64808
64809 }
64810
64811
64812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64813   void * jresult ;
64814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64815   SwigDirector_ViewImpl *darg = 0;
64816   Dali::Vector3 result;
64817
64818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64820   if (!darg) {
64821     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64822     return 0;
64823   }
64824   {
64825     try {
64826       result = (darg)->GetNaturalSize();
64827     } catch (std::out_of_range& e) {
64828       {
64829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64830       };
64831     } catch (std::exception& e) {
64832       {
64833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64834       };
64835     } catch (Dali::DaliException e) {
64836       {
64837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64838       };
64839     } catch (...) {
64840       {
64841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64842       };
64843     }
64844   }
64845
64846   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64847   return jresult;
64848 }
64849
64850
64851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64852   void * jresult ;
64853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64854   SwigDirector_ViewImpl *darg = 0;
64855   Dali::Vector3 result;
64856
64857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64858   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64859   if (!darg) {
64860     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64861     return 0;
64862   }
64863   {
64864     try {
64865       result = (darg)->GetNaturalSizeSwigPublic();
64866     } catch (std::out_of_range& e) {
64867       {
64868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (std::exception& e) {
64871       {
64872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (Dali::DaliException e) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64877       };
64878     } catch (...) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64881       };
64882     }
64883   }
64884
64885   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64886   return jresult;
64887 }
64888
64889
64890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64891   float jresult ;
64892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64893   Dali::Actor *arg2 = 0 ;
64894   Dali::Dimension::Type arg3 ;
64895   SwigDirector_ViewImpl *darg = 0;
64896   float result;
64897
64898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64899   arg2 = (Dali::Actor *)jarg2;
64900   if (!arg2) {
64901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64902     return 0;
64903   }
64904   arg3 = (Dali::Dimension::Type)jarg3;
64905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64906   if (!darg) {
64907     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64908     return 0;
64909   }
64910   {
64911     try {
64912       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64913     } catch (std::out_of_range& e) {
64914       {
64915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64916       };
64917     } catch (std::exception& e) {
64918       {
64919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (Dali::DaliException e) {
64922       {
64923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64924       };
64925     } catch (...) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64928       };
64929     }
64930   }
64931
64932   jresult = result;
64933   return jresult;
64934 }
64935
64936
64937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64938   float jresult ;
64939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64940   Dali::Actor *arg2 = 0 ;
64941   Dali::Dimension::Type arg3 ;
64942   SwigDirector_ViewImpl *darg = 0;
64943   float result;
64944
64945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64946   arg2 = (Dali::Actor *)jarg2;
64947   if (!arg2) {
64948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64949     return 0;
64950   }
64951   arg3 = (Dali::Dimension::Type)jarg3;
64952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64953   if (!darg) {
64954     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64955     return 0;
64956   }
64957   {
64958     try {
64959       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64960     } catch (std::out_of_range& e) {
64961       {
64962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (std::exception& e) {
64965       {
64966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64967       };
64968     } catch (Dali::DaliException e) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64971       };
64972     } catch (...) {
64973       {
64974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64975       };
64976     }
64977   }
64978
64979   jresult = result;
64980   return jresult;
64981 }
64982
64983
64984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
64985   float jresult ;
64986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64987   float arg2 ;
64988   SwigDirector_ViewImpl *darg = 0;
64989   float result;
64990
64991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64992   arg2 = (float)jarg2;
64993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64994   if (!darg) {
64995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64996     return 0;
64997   }
64998   {
64999     try {
65000       result = (float)(darg)->GetHeightForWidth(arg2);
65001     } catch (std::out_of_range& e) {
65002       {
65003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65004       };
65005     } catch (std::exception& e) {
65006       {
65007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65008       };
65009     } catch (Dali::DaliException e) {
65010       {
65011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65012       };
65013     } catch (...) {
65014       {
65015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65016       };
65017     }
65018   }
65019
65020   jresult = result;
65021   return jresult;
65022 }
65023
65024
65025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65026   float jresult ;
65027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65028   float arg2 ;
65029   SwigDirector_ViewImpl *darg = 0;
65030   float result;
65031
65032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65033   arg2 = (float)jarg2;
65034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65035   if (!darg) {
65036     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65037     return 0;
65038   }
65039   {
65040     try {
65041       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65042     } catch (std::out_of_range& e) {
65043       {
65044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65045       };
65046     } catch (std::exception& e) {
65047       {
65048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65049       };
65050     } catch (Dali::DaliException e) {
65051       {
65052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65053       };
65054     } catch (...) {
65055       {
65056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65057       };
65058     }
65059   }
65060
65061   jresult = result;
65062   return jresult;
65063 }
65064
65065
65066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65067   float jresult ;
65068   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65069   float arg2 ;
65070   SwigDirector_ViewImpl *darg = 0;
65071   float result;
65072
65073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65074   arg2 = (float)jarg2;
65075   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65076   if (!darg) {
65077     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65078     return 0;
65079   }
65080   {
65081     try {
65082       result = (float)(darg)->GetWidthForHeight(arg2);
65083     } catch (std::out_of_range& e) {
65084       {
65085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65086       };
65087     } catch (std::exception& e) {
65088       {
65089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65090       };
65091     } catch (Dali::DaliException e) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65094       };
65095     } catch (...) {
65096       {
65097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65098       };
65099     }
65100   }
65101
65102   jresult = result;
65103   return jresult;
65104 }
65105
65106
65107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65108   float jresult ;
65109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65110   float arg2 ;
65111   SwigDirector_ViewImpl *darg = 0;
65112   float result;
65113
65114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65115   arg2 = (float)jarg2;
65116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65117   if (!darg) {
65118     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65119     return 0;
65120   }
65121   {
65122     try {
65123       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65124     } catch (std::out_of_range& e) {
65125       {
65126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65127       };
65128     } catch (std::exception& e) {
65129       {
65130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65131       };
65132     } catch (Dali::DaliException e) {
65133       {
65134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65135       };
65136     } catch (...) {
65137       {
65138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65139       };
65140     }
65141   }
65142
65143   jresult = result;
65144   return jresult;
65145 }
65146
65147
65148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65149   unsigned int jresult ;
65150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65151   Dali::Dimension::Type arg2 ;
65152   SwigDirector_ViewImpl *darg = 0;
65153   bool result;
65154
65155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65156   arg2 = (Dali::Dimension::Type)jarg2;
65157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65158   if (!darg) {
65159     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65160     return 0;
65161   }
65162   {
65163     try {
65164       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65165     } catch (std::out_of_range& e) {
65166       {
65167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65168       };
65169     } catch (std::exception& e) {
65170       {
65171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65172       };
65173     } catch (Dali::DaliException e) {
65174       {
65175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65176       };
65177     } catch (...) {
65178       {
65179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65180       };
65181     }
65182   }
65183
65184   jresult = result;
65185   return jresult;
65186 }
65187
65188
65189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65190   unsigned int jresult ;
65191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65192   Dali::Dimension::Type arg2 ;
65193   SwigDirector_ViewImpl *darg = 0;
65194   bool result;
65195
65196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65197   arg2 = (Dali::Dimension::Type)jarg2;
65198   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65199   if (!darg) {
65200     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65201     return 0;
65202   }
65203   {
65204     try {
65205       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65206     } catch (std::out_of_range& e) {
65207       {
65208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65209       };
65210     } catch (std::exception& e) {
65211       {
65212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65213       };
65214     } catch (Dali::DaliException e) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65217       };
65218     } catch (...) {
65219       {
65220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65221       };
65222     }
65223   }
65224
65225   jresult = result;
65226   return jresult;
65227 }
65228
65229
65230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65231   unsigned int jresult ;
65232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65233   SwigDirector_ViewImpl *darg = 0;
65234   bool result;
65235
65236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65237   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65238   if (!darg) {
65239     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65240     return 0;
65241   }
65242   {
65243     try {
65244       result = (bool)(darg)->RelayoutDependentOnChildren();
65245     } catch (std::out_of_range& e) {
65246       {
65247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65248       };
65249     } catch (std::exception& e) {
65250       {
65251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65252       };
65253     } catch (Dali::DaliException e) {
65254       {
65255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65256       };
65257     } catch (...) {
65258       {
65259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65260       };
65261     }
65262   }
65263
65264   jresult = result;
65265   return jresult;
65266 }
65267
65268
65269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65270   unsigned int jresult ;
65271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65272   SwigDirector_ViewImpl *darg = 0;
65273   bool result;
65274
65275   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65277   if (!darg) {
65278     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65279     return 0;
65280   }
65281   {
65282     try {
65283       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65284     } catch (std::out_of_range& e) {
65285       {
65286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65287       };
65288     } catch (std::exception& e) {
65289       {
65290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65291       };
65292     } catch (Dali::DaliException e) {
65293       {
65294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65295       };
65296     } catch (...) {
65297       {
65298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65299       };
65300     }
65301   }
65302
65303   jresult = result;
65304   return jresult;
65305 }
65306
65307
65308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65310   Dali::Dimension::Type arg2 ;
65311   SwigDirector_ViewImpl *darg = 0;
65312
65313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65314   arg2 = (Dali::Dimension::Type)jarg2;
65315   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65316   if (!darg) {
65317     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65318     return;
65319   }
65320   {
65321     try {
65322       (darg)->OnCalculateRelayoutSize(arg2);
65323     } catch (std::out_of_range& e) {
65324       {
65325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65326       };
65327     } catch (std::exception& e) {
65328       {
65329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65330       };
65331     } catch (Dali::DaliException e) {
65332       {
65333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65334       };
65335     } catch (...) {
65336       {
65337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65338       };
65339     }
65340   }
65341
65342 }
65343
65344
65345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65347   Dali::Dimension::Type arg2 ;
65348   SwigDirector_ViewImpl *darg = 0;
65349
65350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65351   arg2 = (Dali::Dimension::Type)jarg2;
65352   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65353   if (!darg) {
65354     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65355     return;
65356   }
65357   {
65358     try {
65359       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65360     } catch (std::out_of_range& e) {
65361       {
65362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65363       };
65364     } catch (std::exception& e) {
65365       {
65366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65367       };
65368     } catch (Dali::DaliException e) {
65369       {
65370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65371       };
65372     } catch (...) {
65373       {
65374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65375       };
65376     }
65377   }
65378
65379 }
65380
65381
65382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65384   float arg2 ;
65385   Dali::Dimension::Type arg3 ;
65386   SwigDirector_ViewImpl *darg = 0;
65387
65388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65389   arg2 = (float)jarg2;
65390   arg3 = (Dali::Dimension::Type)jarg3;
65391   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65392   if (!darg) {
65393     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65394     return;
65395   }
65396   {
65397     try {
65398       (darg)->OnLayoutNegotiated(arg2,arg3);
65399     } catch (std::out_of_range& e) {
65400       {
65401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65402       };
65403     } catch (std::exception& e) {
65404       {
65405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65406       };
65407     } catch (Dali::DaliException e) {
65408       {
65409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65410       };
65411     } catch (...) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65414       };
65415     }
65416   }
65417
65418 }
65419
65420
65421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65423   float arg2 ;
65424   Dali::Dimension::Type arg3 ;
65425   SwigDirector_ViewImpl *darg = 0;
65426
65427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65428   arg2 = (float)jarg2;
65429   arg3 = (Dali::Dimension::Type)jarg3;
65430   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65431   if (!darg) {
65432     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65433     return;
65434   }
65435   {
65436     try {
65437       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65438     } catch (std::out_of_range& e) {
65439       {
65440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65441       };
65442     } catch (std::exception& e) {
65443       {
65444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65445       };
65446     } catch (Dali::DaliException e) {
65447       {
65448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65449       };
65450     } catch (...) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65453       };
65454     }
65455   }
65456
65457 }
65458
65459
65460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65462
65463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65464   {
65465     try {
65466       (arg1)->OnInitialize();
65467     } catch (std::out_of_range& e) {
65468       {
65469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65470       };
65471     } catch (std::exception& e) {
65472       {
65473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65474       };
65475     } catch (Dali::DaliException e) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65478       };
65479     } catch (...) {
65480       {
65481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65482       };
65483     }
65484   }
65485
65486 }
65487
65488
65489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65491
65492   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65493   {
65494     try {
65495       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65496     } catch (std::out_of_range& e) {
65497       {
65498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65499       };
65500     } catch (std::exception& e) {
65501       {
65502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65503       };
65504     } catch (Dali::DaliException e) {
65505       {
65506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65511       };
65512     }
65513   }
65514
65515 }
65516
65517
65518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65520   Dali::Actor *arg2 = 0 ;
65521
65522   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65523   arg2 = (Dali::Actor *)jarg2;
65524   if (!arg2) {
65525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65526     return ;
65527   }
65528   {
65529     try {
65530       (arg1)->OnControlChildAdd(*arg2);
65531     } catch (std::out_of_range& e) {
65532       {
65533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65534       };
65535     } catch (std::exception& e) {
65536       {
65537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65538       };
65539     } catch (Dali::DaliException e) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65546       };
65547     }
65548   }
65549
65550 }
65551
65552
65553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65555   Dali::Actor *arg2 = 0 ;
65556
65557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65558   arg2 = (Dali::Actor *)jarg2;
65559   if (!arg2) {
65560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65561     return ;
65562   }
65563   {
65564     try {
65565       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65566     } catch (std::out_of_range& e) {
65567       {
65568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65569       };
65570     } catch (std::exception& e) {
65571       {
65572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65573       };
65574     } catch (Dali::DaliException e) {
65575       {
65576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65577       };
65578     } catch (...) {
65579       {
65580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65581       };
65582     }
65583   }
65584
65585 }
65586
65587
65588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65590   Dali::Actor *arg2 = 0 ;
65591
65592   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65593   arg2 = (Dali::Actor *)jarg2;
65594   if (!arg2) {
65595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65596     return ;
65597   }
65598   {
65599     try {
65600       (arg1)->OnControlChildRemove(*arg2);
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65608       };
65609     } catch (Dali::DaliException e) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65612       };
65613     } catch (...) {
65614       {
65615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65616       };
65617     }
65618   }
65619
65620 }
65621
65622
65623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65625   Dali::Actor *arg2 = 0 ;
65626
65627   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65628   arg2 = (Dali::Actor *)jarg2;
65629   if (!arg2) {
65630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65631     return ;
65632   }
65633   {
65634     try {
65635       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65636     } catch (std::out_of_range& e) {
65637       {
65638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65639       };
65640     } catch (std::exception& e) {
65641       {
65642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65643       };
65644     } catch (Dali::DaliException e) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65647       };
65648     } catch (...) {
65649       {
65650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65651       };
65652     }
65653   }
65654
65655 }
65656
65657
65658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65660   Dali::Toolkit::StyleManager arg2 ;
65661   Dali::StyleChange::Type arg3 ;
65662   Dali::Toolkit::StyleManager *argp2 ;
65663
65664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65665   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65666   if (!argp2) {
65667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65668     return ;
65669   }
65670   arg2 = *argp2;
65671   arg3 = (Dali::StyleChange::Type)jarg3;
65672   {
65673     try {
65674       (arg1)->OnStyleChange(arg2,arg3);
65675     } catch (std::out_of_range& e) {
65676       {
65677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65678       };
65679     } catch (std::exception& e) {
65680       {
65681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65682       };
65683     } catch (Dali::DaliException e) {
65684       {
65685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65686       };
65687     } catch (...) {
65688       {
65689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65690       };
65691     }
65692   }
65693
65694 }
65695
65696
65697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65699   Dali::Toolkit::StyleManager arg2 ;
65700   Dali::StyleChange::Type arg3 ;
65701   Dali::Toolkit::StyleManager *argp2 ;
65702
65703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65704   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65705   if (!argp2) {
65706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65707     return ;
65708   }
65709   arg2 = *argp2;
65710   arg3 = (Dali::StyleChange::Type)jarg3;
65711   {
65712     try {
65713       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65714     } catch (std::out_of_range& e) {
65715       {
65716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65717       };
65718     } catch (std::exception& e) {
65719       {
65720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65721       };
65722     } catch (Dali::DaliException e) {
65723       {
65724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65725       };
65726     } catch (...) {
65727       {
65728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65729       };
65730     }
65731   }
65732
65733 }
65734
65735
65736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65737   unsigned int jresult ;
65738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65739   bool result;
65740
65741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65742   {
65743     try {
65744       result = (bool)(arg1)->OnAccessibilityActivated();
65745     } catch (std::out_of_range& e) {
65746       {
65747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (std::exception& e) {
65750       {
65751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65752       };
65753     } catch (Dali::DaliException e) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65756       };
65757     } catch (...) {
65758       {
65759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65760       };
65761     }
65762   }
65763
65764   jresult = result;
65765   return jresult;
65766 }
65767
65768
65769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65770   unsigned int jresult ;
65771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65772   bool result;
65773
65774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65775   {
65776     try {
65777       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65778     } catch (std::out_of_range& e) {
65779       {
65780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65781       };
65782     } catch (std::exception& e) {
65783       {
65784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65785       };
65786     } catch (Dali::DaliException e) {
65787       {
65788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65789       };
65790     } catch (...) {
65791       {
65792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65793       };
65794     }
65795   }
65796
65797   jresult = result;
65798   return jresult;
65799 }
65800
65801
65802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65803   unsigned int jresult ;
65804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65805   Dali::PanGesture arg2 ;
65806   Dali::PanGesture *argp2 ;
65807   bool result;
65808
65809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65810   argp2 = (Dali::PanGesture *)jarg2;
65811   if (!argp2) {
65812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65813     return 0;
65814   }
65815   arg2 = *argp2;
65816   {
65817     try {
65818       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65819     } catch (std::out_of_range& e) {
65820       {
65821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65822       };
65823     } catch (std::exception& e) {
65824       {
65825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65826       };
65827     } catch (Dali::DaliException e) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65830       };
65831     } catch (...) {
65832       {
65833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65834       };
65835     }
65836   }
65837
65838   jresult = result;
65839   return jresult;
65840 }
65841
65842
65843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65844   unsigned int jresult ;
65845   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65846   Dali::PanGesture arg2 ;
65847   Dali::PanGesture *argp2 ;
65848   bool result;
65849
65850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65851   argp2 = (Dali::PanGesture *)jarg2;
65852   if (!argp2) {
65853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65854     return 0;
65855   }
65856   arg2 = *argp2;
65857   {
65858     try {
65859       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65860     } catch (std::out_of_range& e) {
65861       {
65862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65863       };
65864     } catch (std::exception& e) {
65865       {
65866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65867       };
65868     } catch (Dali::DaliException e) {
65869       {
65870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65871       };
65872     } catch (...) {
65873       {
65874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65875       };
65876     }
65877   }
65878
65879   jresult = result;
65880   return jresult;
65881 }
65882
65883
65884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65885   unsigned int jresult ;
65886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65887   Dali::TouchEvent *arg2 = 0 ;
65888   bool result;
65889
65890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65891   arg2 = (Dali::TouchEvent *)jarg2;
65892   if (!arg2) {
65893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65894     return 0;
65895   }
65896   {
65897     try {
65898       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65899     } catch (std::out_of_range& e) {
65900       {
65901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65902       };
65903     } catch (std::exception& e) {
65904       {
65905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65906       };
65907     } catch (Dali::DaliException e) {
65908       {
65909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65910       };
65911     } catch (...) {
65912       {
65913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65914       };
65915     }
65916   }
65917
65918   jresult = result;
65919   return jresult;
65920 }
65921
65922
65923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65924   unsigned int jresult ;
65925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65926   Dali::TouchEvent *arg2 = 0 ;
65927   bool result;
65928
65929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65930   arg2 = (Dali::TouchEvent *)jarg2;
65931   if (!arg2) {
65932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65933     return 0;
65934   }
65935   {
65936     try {
65937       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65945       };
65946     } catch (Dali::DaliException e) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65949       };
65950     } catch (...) {
65951       {
65952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65953       };
65954     }
65955   }
65956
65957   jresult = result;
65958   return jresult;
65959 }
65960
65961
65962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65963   unsigned int jresult ;
65964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65965   bool arg2 ;
65966   bool result;
65967
65968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65969   arg2 = jarg2 ? true : false;
65970   {
65971     try {
65972       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
65973     } catch (std::out_of_range& e) {
65974       {
65975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65976       };
65977     } catch (std::exception& e) {
65978       {
65979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65980       };
65981     } catch (Dali::DaliException e) {
65982       {
65983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65984       };
65985     } catch (...) {
65986       {
65987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65988       };
65989     }
65990   }
65991
65992   jresult = result;
65993   return jresult;
65994 }
65995
65996
65997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
65998   unsigned int jresult ;
65999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66000   bool arg2 ;
66001   bool result;
66002
66003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66004   arg2 = jarg2 ? true : false;
66005   {
66006     try {
66007       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66008     } catch (std::out_of_range& e) {
66009       {
66010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66011       };
66012     } catch (std::exception& e) {
66013       {
66014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66015       };
66016     } catch (Dali::DaliException e) {
66017       {
66018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66019       };
66020     } catch (...) {
66021       {
66022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66023       };
66024     }
66025   }
66026
66027   jresult = result;
66028   return jresult;
66029 }
66030
66031
66032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66033   unsigned int jresult ;
66034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66035   bool result;
66036
66037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66038   {
66039     try {
66040       result = (bool)(arg1)->OnAccessibilityZoom();
66041     } catch (std::out_of_range& e) {
66042       {
66043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66044       };
66045     } catch (std::exception& e) {
66046       {
66047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66048       };
66049     } catch (Dali::DaliException e) {
66050       {
66051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66052       };
66053     } catch (...) {
66054       {
66055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66056       };
66057     }
66058   }
66059
66060   jresult = result;
66061   return jresult;
66062 }
66063
66064
66065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66066   unsigned int jresult ;
66067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66068   bool result;
66069
66070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66071   {
66072     try {
66073       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (Dali::DaliException e) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66089       };
66090     }
66091   }
66092
66093   jresult = result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66099   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66100
66101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66102   {
66103     try {
66104       (arg1)->OnKeyInputFocusGained();
66105     } catch (std::out_of_range& e) {
66106       {
66107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66108       };
66109     } catch (std::exception& e) {
66110       {
66111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66112       };
66113     } catch (Dali::DaliException e) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66116       };
66117     } catch (...) {
66118       {
66119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66120       };
66121     }
66122   }
66123
66124 }
66125
66126
66127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66129
66130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66131   {
66132     try {
66133       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66134     } catch (std::out_of_range& e) {
66135       {
66136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66137       };
66138     } catch (std::exception& e) {
66139       {
66140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66141       };
66142     } catch (Dali::DaliException e) {
66143       {
66144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66145       };
66146     } catch (...) {
66147       {
66148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66149       };
66150     }
66151   }
66152
66153 }
66154
66155
66156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66158
66159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66160   {
66161     try {
66162       (arg1)->OnKeyInputFocusLost();
66163     } catch (std::out_of_range& e) {
66164       {
66165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66166       };
66167     } catch (std::exception& e) {
66168       {
66169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66170       };
66171     } catch (Dali::DaliException e) {
66172       {
66173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66174       };
66175     } catch (...) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66178       };
66179     }
66180   }
66181
66182 }
66183
66184
66185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66187
66188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66189   {
66190     try {
66191       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66192     } catch (std::out_of_range& e) {
66193       {
66194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66195       };
66196     } catch (std::exception& e) {
66197       {
66198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66199       };
66200     } catch (Dali::DaliException e) {
66201       {
66202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66203       };
66204     } catch (...) {
66205       {
66206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66207       };
66208     }
66209   }
66210
66211 }
66212
66213
66214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66215   void * jresult ;
66216   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66217   Dali::Actor arg2 ;
66218   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66219   bool arg4 ;
66220   Dali::Actor *argp2 ;
66221   Dali::Actor result;
66222
66223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66224   argp2 = (Dali::Actor *)jarg2;
66225   if (!argp2) {
66226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66227     return 0;
66228   }
66229   arg2 = *argp2;
66230   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66231   arg4 = jarg4 ? true : false;
66232   {
66233     try {
66234       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66235     } catch (std::out_of_range& e) {
66236       {
66237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66238       };
66239     } catch (std::exception& e) {
66240       {
66241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66242       };
66243     } catch (Dali::DaliException e) {
66244       {
66245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66246       };
66247     } catch (...) {
66248       {
66249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66250       };
66251     }
66252   }
66253
66254   jresult = new Dali::Actor((const Dali::Actor &)result);
66255   return jresult;
66256 }
66257
66258
66259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66260   void * jresult ;
66261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66262   Dali::Actor arg2 ;
66263   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66264   bool arg4 ;
66265   Dali::Actor *argp2 ;
66266   Dali::Actor result;
66267
66268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66269   argp2 = (Dali::Actor *)jarg2;
66270   if (!argp2) {
66271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66272     return 0;
66273   }
66274   arg2 = *argp2;
66275   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66276   arg4 = jarg4 ? true : false;
66277   {
66278     try {
66279       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66280     } catch (std::out_of_range& e) {
66281       {
66282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66283       };
66284     } catch (std::exception& e) {
66285       {
66286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66287       };
66288     } catch (Dali::DaliException e) {
66289       {
66290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66291       };
66292     } catch (...) {
66293       {
66294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66295       };
66296     }
66297   }
66298
66299   jresult = new Dali::Actor((const Dali::Actor &)result);
66300   return jresult;
66301 }
66302
66303
66304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66306   Dali::Actor arg2 ;
66307   Dali::Actor *argp2 ;
66308
66309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66310   argp2 = (Dali::Actor *)jarg2;
66311   if (!argp2) {
66312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66313     return ;
66314   }
66315   arg2 = *argp2;
66316   {
66317     try {
66318       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66319     } catch (std::out_of_range& e) {
66320       {
66321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66322       };
66323     } catch (std::exception& e) {
66324       {
66325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66326       };
66327     } catch (Dali::DaliException e) {
66328       {
66329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66330       };
66331     } catch (...) {
66332       {
66333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66334       };
66335     }
66336   }
66337
66338 }
66339
66340
66341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66343   Dali::Actor arg2 ;
66344   Dali::Actor *argp2 ;
66345
66346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66347   argp2 = (Dali::Actor *)jarg2;
66348   if (!argp2) {
66349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66350     return ;
66351   }
66352   arg2 = *argp2;
66353   {
66354     try {
66355       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66356     } catch (std::out_of_range& e) {
66357       {
66358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66359       };
66360     } catch (std::exception& e) {
66361       {
66362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66363       };
66364     } catch (Dali::DaliException e) {
66365       {
66366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66367       };
66368     } catch (...) {
66369       {
66370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66371       };
66372     }
66373   }
66374
66375 }
66376
66377
66378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66379   unsigned int jresult ;
66380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66381   bool result;
66382
66383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66384   {
66385     try {
66386       result = (bool)(arg1)->OnKeyboardEnter();
66387     } catch (std::out_of_range& e) {
66388       {
66389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66390       };
66391     } catch (std::exception& e) {
66392       {
66393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66394       };
66395     } catch (Dali::DaliException e) {
66396       {
66397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66398       };
66399     } catch (...) {
66400       {
66401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66402       };
66403     }
66404   }
66405
66406   jresult = result;
66407   return jresult;
66408 }
66409
66410
66411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66412   unsigned int jresult ;
66413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66414   bool result;
66415
66416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66417   {
66418     try {
66419       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66420     } catch (std::out_of_range& e) {
66421       {
66422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66423       };
66424     } catch (std::exception& e) {
66425       {
66426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66427       };
66428     } catch (Dali::DaliException e) {
66429       {
66430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66431       };
66432     } catch (...) {
66433       {
66434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66435       };
66436     }
66437   }
66438
66439   jresult = result;
66440   return jresult;
66441 }
66442
66443
66444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66446   Dali::PinchGesture *arg2 = 0 ;
66447
66448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66449   arg2 = (Dali::PinchGesture *)jarg2;
66450   if (!arg2) {
66451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66452     return ;
66453   }
66454   {
66455     try {
66456       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66457     } catch (std::out_of_range& e) {
66458       {
66459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66460       };
66461     } catch (std::exception& e) {
66462       {
66463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66464       };
66465     } catch (Dali::DaliException e) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66468       };
66469     } catch (...) {
66470       {
66471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66472       };
66473     }
66474   }
66475
66476 }
66477
66478
66479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66481   Dali::PinchGesture *arg2 = 0 ;
66482
66483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66484   arg2 = (Dali::PinchGesture *)jarg2;
66485   if (!arg2) {
66486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66487     return ;
66488   }
66489   {
66490     try {
66491       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66492     } catch (std::out_of_range& e) {
66493       {
66494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66495       };
66496     } catch (std::exception& e) {
66497       {
66498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66499       };
66500     } catch (Dali::DaliException e) {
66501       {
66502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66503       };
66504     } catch (...) {
66505       {
66506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66507       };
66508     }
66509   }
66510
66511 }
66512
66513
66514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66515   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66516   Dali::PanGesture *arg2 = 0 ;
66517
66518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66519   arg2 = (Dali::PanGesture *)jarg2;
66520   if (!arg2) {
66521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66522     return ;
66523   }
66524   {
66525     try {
66526       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66527     } catch (std::out_of_range& e) {
66528       {
66529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66530       };
66531     } catch (std::exception& e) {
66532       {
66533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66534       };
66535     } catch (Dali::DaliException e) {
66536       {
66537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66538       };
66539     } catch (...) {
66540       {
66541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66542       };
66543     }
66544   }
66545
66546 }
66547
66548
66549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66551   Dali::PanGesture *arg2 = 0 ;
66552
66553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66554   arg2 = (Dali::PanGesture *)jarg2;
66555   if (!arg2) {
66556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66557     return ;
66558   }
66559   {
66560     try {
66561       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66562     } catch (std::out_of_range& e) {
66563       {
66564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66565       };
66566     } catch (std::exception& e) {
66567       {
66568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66569       };
66570     } catch (Dali::DaliException e) {
66571       {
66572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66573       };
66574     } catch (...) {
66575       {
66576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66577       };
66578     }
66579   }
66580
66581 }
66582
66583
66584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66586   Dali::TapGesture *arg2 = 0 ;
66587
66588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66589   arg2 = (Dali::TapGesture *)jarg2;
66590   if (!arg2) {
66591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66592     return ;
66593   }
66594   {
66595     try {
66596       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66597     } catch (std::out_of_range& e) {
66598       {
66599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66600       };
66601     } catch (std::exception& e) {
66602       {
66603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66604       };
66605     } catch (Dali::DaliException e) {
66606       {
66607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66608       };
66609     } catch (...) {
66610       {
66611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66612       };
66613     }
66614   }
66615
66616 }
66617
66618
66619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66621   Dali::TapGesture *arg2 = 0 ;
66622
66623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66624   arg2 = (Dali::TapGesture *)jarg2;
66625   if (!arg2) {
66626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66627     return ;
66628   }
66629   {
66630     try {
66631       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66632     } catch (std::out_of_range& e) {
66633       {
66634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66635       };
66636     } catch (std::exception& e) {
66637       {
66638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66639       };
66640     } catch (Dali::DaliException e) {
66641       {
66642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66643       };
66644     } catch (...) {
66645       {
66646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66647       };
66648     }
66649   }
66650
66651 }
66652
66653
66654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66656   Dali::LongPressGesture *arg2 = 0 ;
66657
66658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66659   arg2 = (Dali::LongPressGesture *)jarg2;
66660   if (!arg2) {
66661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66662     return ;
66663   }
66664   {
66665     try {
66666       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66667     } catch (std::out_of_range& e) {
66668       {
66669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66670       };
66671     } catch (std::exception& e) {
66672       {
66673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66674       };
66675     } catch (Dali::DaliException e) {
66676       {
66677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66678       };
66679     } catch (...) {
66680       {
66681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66682       };
66683     }
66684   }
66685
66686 }
66687
66688
66689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66691   Dali::LongPressGesture *arg2 = 0 ;
66692
66693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66694   arg2 = (Dali::LongPressGesture *)jarg2;
66695   if (!arg2) {
66696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66697     return ;
66698   }
66699   {
66700     try {
66701       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66702     } catch (std::out_of_range& e) {
66703       {
66704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66705       };
66706     } catch (std::exception& e) {
66707       {
66708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66709       };
66710     } catch (Dali::DaliException e) {
66711       {
66712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66713       };
66714     } catch (...) {
66715       {
66716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66717       };
66718     }
66719   }
66720
66721 }
66722
66723
66724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66726   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66727   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66728
66729   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66730   arg2 = (Dali::SlotObserver *)jarg2;
66731   arg3 = (Dali::CallbackBase *)jarg3;
66732   {
66733     try {
66734       (arg1)->SignalConnected(arg2,arg3);
66735     } catch (std::out_of_range& e) {
66736       {
66737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66738       };
66739     } catch (std::exception& e) {
66740       {
66741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66742       };
66743     } catch (Dali::DaliException e) {
66744       {
66745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66746       };
66747     } catch (...) {
66748       {
66749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66750       };
66751     }
66752   }
66753
66754 }
66755
66756
66757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66759   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66760   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66761
66762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66763   arg2 = (Dali::SlotObserver *)jarg2;
66764   arg3 = (Dali::CallbackBase *)jarg3;
66765   {
66766     try {
66767       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66768     } catch (std::out_of_range& e) {
66769       {
66770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66771       };
66772     } catch (std::exception& e) {
66773       {
66774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66775       };
66776     } catch (Dali::DaliException e) {
66777       {
66778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66779       };
66780     } catch (...) {
66781       {
66782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66783       };
66784     }
66785   }
66786
66787 }
66788
66789
66790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66792   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66793   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66794
66795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66796   arg2 = (Dali::SlotObserver *)jarg2;
66797   arg3 = (Dali::CallbackBase *)jarg3;
66798   {
66799     try {
66800       (arg1)->SignalDisconnected(arg2,arg3);
66801     } catch (std::out_of_range& e) {
66802       {
66803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66804       };
66805     } catch (std::exception& e) {
66806       {
66807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66808       };
66809     } catch (Dali::DaliException e) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66812       };
66813     } catch (...) {
66814       {
66815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66816       };
66817     }
66818   }
66819
66820 }
66821
66822
66823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66824   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66825   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66826   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66827
66828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66829   arg2 = (Dali::SlotObserver *)jarg2;
66830   arg3 = (Dali::CallbackBase *)jarg3;
66831   {
66832     try {
66833       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66834     } catch (std::out_of_range& e) {
66835       {
66836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66837       };
66838     } catch (std::exception& e) {
66839       {
66840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66841       };
66842     } catch (Dali::DaliException e) {
66843       {
66844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66845       };
66846     } catch (...) {
66847       {
66848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66849       };
66850     }
66851   }
66852
66853 }
66854
66855
66856 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) {
66857   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66858   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66859   if (director) {
66860     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);
66861   }
66862 }
66863
66864
66865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66866   void * jresult ;
66867   Dali::Toolkit::Control *arg1 = 0 ;
66868   Dali::Toolkit::Internal::Control *result = 0 ;
66869
66870   arg1 = (Dali::Toolkit::Control *)jarg1;
66871   if (!arg1) {
66872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66873     return 0;
66874   }
66875   {
66876     try {
66877       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66878     } catch (std::out_of_range& e) {
66879       {
66880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66881       };
66882     } catch (std::exception& e) {
66883       {
66884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66885       };
66886     } catch (Dali::DaliException e) {
66887       {
66888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66889       };
66890     } catch (...) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66893       };
66894     }
66895   }
66896
66897   jresult = (void *)result;
66898   return jresult;
66899 }
66900
66901
66902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66903   int jresult ;
66904   int result;
66905
66906   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66907   jresult = (int)result;
66908   return jresult;
66909 }
66910
66911
66912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
66913   int jresult ;
66914   int result;
66915
66916   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
66917   jresult = (int)result;
66918   return jresult;
66919 }
66920
66921
66922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
66923   int jresult ;
66924   int result;
66925
66926   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
66927   jresult = (int)result;
66928   return jresult;
66929 }
66930
66931
66932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66933   int jresult ;
66934   int result;
66935
66936   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66937   jresult = (int)result;
66938   return jresult;
66939 }
66940
66941
66942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66943   int jresult ;
66944   int result;
66945
66946   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66947   jresult = (int)result;
66948   return jresult;
66949 }
66950
66951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66952   int jresult ;
66953   int result;
66954
66955   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66956   jresult = (int)result;
66957   return jresult;
66958 }
66959
66960
66961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66962   int jresult ;
66963   int result;
66964
66965   result = (int)Dali::Toolkit::Control::Property::PADDING;
66966   jresult = (int)result;
66967   return jresult;
66968 }
66969
66970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66971   void * jresult ;
66972   Dali::Toolkit::Control::Property *result = 0 ;
66973
66974   {
66975     try {
66976       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66977     } catch (std::out_of_range& e) {
66978       {
66979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66980       };
66981     } catch (std::exception& e) {
66982       {
66983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66984       };
66985     } catch (Dali::DaliException e) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66988       };
66989     } catch (...) {
66990       {
66991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66992       };
66993     }
66994   }
66995
66996   jresult = (void *)result;
66997   return jresult;
66998 }
66999
67000
67001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67002   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67003
67004   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67005   {
67006     try {
67007       delete arg1;
67008     } catch (std::out_of_range& e) {
67009       {
67010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67011       };
67012     } catch (std::exception& e) {
67013       {
67014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67015       };
67016     } catch (Dali::DaliException e) {
67017       {
67018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67019       };
67020     } catch (...) {
67021       {
67022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67023       };
67024     }
67025   }
67026
67027 }
67028
67029
67030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67031   void * jresult ;
67032   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67033
67034   {
67035     try {
67036       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67037     } catch (std::out_of_range& e) {
67038       {
67039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67040       };
67041     } catch (std::exception& e) {
67042       {
67043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (Dali::DaliException e) {
67046       {
67047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67048       };
67049     } catch (...) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67052       };
67053     }
67054   }
67055
67056   jresult = (void *)result;
67057   return jresult;
67058 }
67059
67060
67061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67062   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67063
67064   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67065   {
67066     try {
67067       delete arg1;
67068     } catch (std::out_of_range& e) {
67069       {
67070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67071       };
67072     } catch (std::exception& e) {
67073       {
67074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67075       };
67076     } catch (Dali::DaliException e) {
67077       {
67078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67079       };
67080     } catch (...) {
67081       {
67082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67083       };
67084     }
67085   }
67086
67087 }
67088
67089
67090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67091   void * jresult ;
67092   Dali::Toolkit::Control result;
67093
67094   {
67095     try {
67096       result = Dali::Toolkit::Control::New();
67097     } catch (std::out_of_range& e) {
67098       {
67099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67100       };
67101     } catch (std::exception& e) {
67102       {
67103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67104       };
67105     } catch (Dali::DaliException e) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67108       };
67109     } catch (...) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67112       };
67113     }
67114   }
67115
67116   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67117   return jresult;
67118 }
67119
67120
67121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67122   void * jresult ;
67123   Dali::Toolkit::Control *result = 0 ;
67124
67125   {
67126     try {
67127       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67128     } catch (std::out_of_range& e) {
67129       {
67130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67131       };
67132     } catch (std::exception& e) {
67133       {
67134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67135       };
67136     } catch (Dali::DaliException e) {
67137       {
67138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67139       };
67140     } catch (...) {
67141       {
67142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67143       };
67144     }
67145   }
67146
67147   jresult = (void *)result;
67148   return jresult;
67149 }
67150
67151
67152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67153   void * jresult ;
67154   Dali::Toolkit::Control *arg1 = 0 ;
67155   Dali::Toolkit::Control *result = 0 ;
67156
67157   arg1 = (Dali::Toolkit::Control *)jarg1;
67158   if (!arg1) {
67159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67160     return 0;
67161   }
67162   {
67163     try {
67164       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67165     } catch (std::out_of_range& e) {
67166       {
67167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67168       };
67169     } catch (std::exception& e) {
67170       {
67171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67172       };
67173     } catch (Dali::DaliException e) {
67174       {
67175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67176       };
67177     } catch (...) {
67178       {
67179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67180       };
67181     }
67182   }
67183
67184   jresult = (void *)result;
67185   return jresult;
67186 }
67187
67188
67189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67191
67192   arg1 = (Dali::Toolkit::Control *)jarg1;
67193   {
67194     try {
67195       delete arg1;
67196     } catch (std::out_of_range& e) {
67197       {
67198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67199       };
67200     } catch (std::exception& e) {
67201       {
67202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67203       };
67204     } catch (Dali::DaliException e) {
67205       {
67206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67207       };
67208     } catch (...) {
67209       {
67210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67211       };
67212     }
67213   }
67214
67215 }
67216
67217
67218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67219   void * jresult ;
67220   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67221   Dali::Toolkit::Control *arg2 = 0 ;
67222   Dali::Toolkit::Control *result = 0 ;
67223
67224   arg1 = (Dali::Toolkit::Control *)jarg1;
67225   arg2 = (Dali::Toolkit::Control *)jarg2;
67226   if (!arg2) {
67227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67228     return 0;
67229   }
67230   {
67231     try {
67232       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67233     } catch (std::out_of_range& e) {
67234       {
67235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67236       };
67237     } catch (std::exception& e) {
67238       {
67239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67240       };
67241     } catch (Dali::DaliException e) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67244       };
67245     } catch (...) {
67246       {
67247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67248       };
67249     }
67250   }
67251
67252   jresult = (void *)result;
67253   return jresult;
67254 }
67255
67256
67257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67258   void * jresult ;
67259   Dali::BaseHandle arg1 ;
67260   Dali::BaseHandle *argp1 ;
67261   Dali::Toolkit::Control result;
67262
67263   argp1 = (Dali::BaseHandle *)jarg1;
67264   if (!argp1) {
67265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67266     return 0;
67267   }
67268   arg1 = *argp1;
67269   {
67270     try {
67271       result = Dali::Toolkit::Control::DownCast(arg1);
67272     } catch (std::out_of_range& e) {
67273       {
67274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (std::exception& e) {
67277       {
67278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67279       };
67280     } catch (Dali::DaliException e) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67283       };
67284     } catch (...) {
67285       {
67286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67287       };
67288     }
67289   }
67290
67291   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67292   return jresult;
67293 }
67294
67295
67296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67297   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67298
67299   arg1 = (Dali::Toolkit::Control *)jarg1;
67300   {
67301     try {
67302       (arg1)->SetKeyInputFocus();
67303     } catch (std::out_of_range& e) {
67304       {
67305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (std::exception& e) {
67308       {
67309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67310       };
67311     } catch (Dali::DaliException e) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67314       };
67315     } catch (...) {
67316       {
67317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67318       };
67319     }
67320   }
67321
67322 }
67323
67324
67325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67326   unsigned int jresult ;
67327   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67328   bool result;
67329
67330   arg1 = (Dali::Toolkit::Control *)jarg1;
67331   {
67332     try {
67333       result = (bool)(arg1)->HasKeyInputFocus();
67334     } catch (std::out_of_range& e) {
67335       {
67336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67337       };
67338     } catch (std::exception& e) {
67339       {
67340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67341       };
67342     } catch (Dali::DaliException e) {
67343       {
67344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67345       };
67346     } catch (...) {
67347       {
67348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67349       };
67350     }
67351   }
67352
67353   jresult = result;
67354   return jresult;
67355 }
67356
67357
67358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67359   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67360
67361   arg1 = (Dali::Toolkit::Control *)jarg1;
67362   {
67363     try {
67364       (arg1)->ClearKeyInputFocus();
67365     } catch (std::out_of_range& e) {
67366       {
67367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67368       };
67369     } catch (std::exception& e) {
67370       {
67371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67372       };
67373     } catch (Dali::DaliException e) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67376       };
67377     } catch (...) {
67378       {
67379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67380       };
67381     }
67382   }
67383
67384 }
67385
67386
67387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67388   void * jresult ;
67389   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67390   Dali::PinchGestureDetector result;
67391
67392   arg1 = (Dali::Toolkit::Control *)jarg1;
67393   {
67394     try {
67395       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67396     } catch (std::out_of_range& e) {
67397       {
67398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (std::exception& e) {
67401       {
67402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (Dali::DaliException e) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67407       };
67408     } catch (...) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67411       };
67412     }
67413   }
67414
67415   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67416   return jresult;
67417 }
67418
67419
67420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67421   void * jresult ;
67422   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67423   Dali::PanGestureDetector result;
67424
67425   arg1 = (Dali::Toolkit::Control *)jarg1;
67426   {
67427     try {
67428       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67429     } catch (std::out_of_range& e) {
67430       {
67431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67432       };
67433     } catch (std::exception& e) {
67434       {
67435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67436       };
67437     } catch (Dali::DaliException e) {
67438       {
67439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67440       };
67441     } catch (...) {
67442       {
67443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67444       };
67445     }
67446   }
67447
67448   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67449   return jresult;
67450 }
67451
67452
67453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67454   void * jresult ;
67455   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67456   Dali::TapGestureDetector result;
67457
67458   arg1 = (Dali::Toolkit::Control *)jarg1;
67459   {
67460     try {
67461       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67462     } catch (std::out_of_range& e) {
67463       {
67464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67465       };
67466     } catch (std::exception& e) {
67467       {
67468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67469       };
67470     } catch (Dali::DaliException e) {
67471       {
67472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67473       };
67474     } catch (...) {
67475       {
67476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67477       };
67478     }
67479   }
67480
67481   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67482   return jresult;
67483 }
67484
67485
67486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67487   void * jresult ;
67488   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67489   Dali::LongPressGestureDetector result;
67490
67491   arg1 = (Dali::Toolkit::Control *)jarg1;
67492   {
67493     try {
67494       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67495     } catch (std::out_of_range& e) {
67496       {
67497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (std::exception& e) {
67500       {
67501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (Dali::DaliException e) {
67504       {
67505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67506       };
67507     } catch (...) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67510       };
67511     }
67512   }
67513
67514   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67515   return jresult;
67516 }
67517
67518
67519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67520   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67521   std::string *arg2 = 0 ;
67522
67523   arg1 = (Dali::Toolkit::Control *)jarg1;
67524   if (!jarg2) {
67525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67526     return ;
67527   }
67528   std::string arg2_str(jarg2);
67529   arg2 = &arg2_str;
67530   {
67531     try {
67532       (arg1)->SetStyleName((std::string const &)*arg2);
67533     } catch (std::out_of_range& e) {
67534       {
67535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67536       };
67537     } catch (std::exception& e) {
67538       {
67539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67540       };
67541     } catch (Dali::DaliException e) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67544       };
67545     } catch (...) {
67546       {
67547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67548       };
67549     }
67550   }
67551
67552
67553   //argout typemap for const std::string&
67554
67555 }
67556
67557
67558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67559   char * jresult ;
67560   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67561   std::string *result = 0 ;
67562
67563   arg1 = (Dali::Toolkit::Control *)jarg1;
67564   {
67565     try {
67566       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67567     } catch (std::out_of_range& e) {
67568       {
67569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67570       };
67571     } catch (std::exception& e) {
67572       {
67573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67574       };
67575     } catch (Dali::DaliException e) {
67576       {
67577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67578       };
67579     } catch (...) {
67580       {
67581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67582       };
67583     }
67584   }
67585
67586   jresult = SWIG_csharp_string_callback(result->c_str());
67587   return jresult;
67588 }
67589
67590
67591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67592   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67593   Dali::Vector4 *arg2 = 0 ;
67594
67595   arg1 = (Dali::Toolkit::Control *)jarg1;
67596   arg2 = (Dali::Vector4 *)jarg2;
67597   if (!arg2) {
67598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67599     return ;
67600   }
67601   {
67602     try {
67603       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67604     } catch (std::out_of_range& e) {
67605       {
67606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67607       };
67608     } catch (std::exception& e) {
67609       {
67610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67611       };
67612     } catch (Dali::DaliException e) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67615       };
67616     } catch (...) {
67617       {
67618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67619       };
67620     }
67621   }
67622
67623 }
67624
67625
67626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67627   void * jresult ;
67628   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67629   Dali::Vector4 result;
67630
67631   arg1 = (Dali::Toolkit::Control *)jarg1;
67632   {
67633     try {
67634       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67635     } catch (std::out_of_range& e) {
67636       {
67637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67638       };
67639     } catch (std::exception& e) {
67640       {
67641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67642       };
67643     } catch (Dali::DaliException e) {
67644       {
67645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67646       };
67647     } catch (...) {
67648       {
67649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67650       };
67651     }
67652   }
67653
67654   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67655   return jresult;
67656 }
67657
67658
67659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67660   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67661   Dali::Image arg2 ;
67662   Dali::Image *argp2 ;
67663
67664   arg1 = (Dali::Toolkit::Control *)jarg1;
67665   argp2 = (Dali::Image *)jarg2;
67666   if (!argp2) {
67667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67668     return ;
67669   }
67670   arg2 = *argp2;
67671   {
67672     try {
67673       (arg1)->SetBackgroundImage(arg2);
67674     } catch (std::out_of_range& e) {
67675       {
67676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67677       };
67678     } catch (std::exception& e) {
67679       {
67680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67681       };
67682     } catch (Dali::DaliException e) {
67683       {
67684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67685       };
67686     } catch (...) {
67687       {
67688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67689       };
67690     }
67691   }
67692
67693 }
67694
67695
67696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67697   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67698
67699   arg1 = (Dali::Toolkit::Control *)jarg1;
67700   {
67701     try {
67702       (arg1)->ClearBackground();
67703     } catch (std::out_of_range& e) {
67704       {
67705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67706       };
67707     } catch (std::exception& e) {
67708       {
67709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67710       };
67711     } catch (Dali::DaliException e) {
67712       {
67713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67714       };
67715     } catch (...) {
67716       {
67717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67718       };
67719     }
67720   }
67721
67722 }
67723
67724
67725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67726   void * jresult ;
67727   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67728   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67729
67730   arg1 = (Dali::Toolkit::Control *)jarg1;
67731   {
67732     try {
67733       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67734     } catch (std::out_of_range& e) {
67735       {
67736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67737       };
67738     } catch (std::exception& e) {
67739       {
67740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67741       };
67742     } catch (Dali::DaliException e) {
67743       {
67744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67745       };
67746     } catch (...) {
67747       {
67748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67749       };
67750     }
67751   }
67752
67753   jresult = (void *)result;
67754   return jresult;
67755 }
67756
67757
67758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67759   void * jresult ;
67760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67761   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67762
67763   arg1 = (Dali::Toolkit::Control *)jarg1;
67764   {
67765     try {
67766       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67767     } catch (std::out_of_range& e) {
67768       {
67769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67770       };
67771     } catch (std::exception& e) {
67772       {
67773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67774       };
67775     } catch (Dali::DaliException e) {
67776       {
67777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67778       };
67779     } catch (...) {
67780       {
67781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67782       };
67783     }
67784   }
67785
67786   jresult = (void *)result;
67787   return jresult;
67788 }
67789
67790
67791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67792   void * jresult ;
67793   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67794   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67795
67796   arg1 = (Dali::Toolkit::Control *)jarg1;
67797   {
67798     try {
67799       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67800     } catch (std::out_of_range& e) {
67801       {
67802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67803       };
67804     } catch (std::exception& e) {
67805       {
67806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67807       };
67808     } catch (Dali::DaliException e) {
67809       {
67810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67811       };
67812     } catch (...) {
67813       {
67814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67815       };
67816     }
67817   }
67818
67819   jresult = (void *)result;
67820   return jresult;
67821 }
67822
67823
67824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67825   void * jresult ;
67826   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67827   Dali::Toolkit::Control *result = 0 ;
67828
67829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67830   if (!arg1) {
67831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67832     return 0;
67833   }
67834   {
67835     try {
67836       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67837     } catch (std::out_of_range& e) {
67838       {
67839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67840       };
67841     } catch (std::exception& e) {
67842       {
67843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67844       };
67845     } catch (Dali::DaliException e) {
67846       {
67847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67848       };
67849     } catch (...) {
67850       {
67851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67852       };
67853     }
67854   }
67855
67856   jresult = (void *)result;
67857   return jresult;
67858 }
67859
67860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67861 {
67862   int jresult;
67863   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67864   arg1 = (Dali::Toolkit::Control *)jarg1;
67865
67866   if (!arg1) {
67867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67868     return 0;
67869   }
67870
67871   Dali::Property::Index arg2 = 0 ;
67872   arg2 = (Dali::Property::Index)jarg2;
67873
67874   Toolkit::Visual::ResourceStatus result;
67875   {
67876     try {
67877       result = arg1->GetVisualResourceStatus(arg2);
67878     } catch (std::out_of_range& e) {
67879       {
67880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67881       };
67882     } catch (std::exception& e) {
67883       {
67884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67885       };
67886     } catch (...) {
67887       {
67888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67889       };
67890     }
67891   }
67892   jresult = (int)(result);
67893   return jresult;
67894 }
67895
67896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67897 {
67898   void * jresult;
67899   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67900   arg1 = (Dali::Toolkit::Control *)jarg1;
67901
67902   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67903
67904   Dali::Toolkit::TransitionData *arg2 = 0 ;
67905   Dali::Animation result;
67906
67907   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67908   if (!arg2) {
67909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67910     return 0;
67911   }
67912   {
67913     try {
67914       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67915     } catch (std::out_of_range& e) {
67916       {
67917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67918       };
67919     } catch (std::exception& e) {
67920       {
67921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (Dali::DaliException e) {
67924       {
67925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67926       };
67927     } catch (...) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67930       };
67931     }
67932   }
67933
67934   jresult = new Dali::Animation((const Dali::Animation &)result);
67935   return jresult;
67936 }
67937
67938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67939 {
67940   Dali::Toolkit::Control arg1;
67941   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67942
67943   if (!argp1) {
67944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67945   }
67946   arg1 = *argp1;
67947
67948   Dali::Property::Index arg2 = 0 ;
67949   arg2 = (Dali::Property::Index)jarg2;
67950
67951   Dali::Property::Index arg3 = 0 ;
67952   arg3 = (Dali::Property::Index)jarg3;
67953
67954   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67955
67956   {
67957     try {
67958       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67966       };
67967     } catch (...) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67970       };
67971     }
67972   }
67973
67974
67975 }
67976
67977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67978   void * jresult ;
67979   Dali::Toolkit::Control *arg1 = 0 ;
67980   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67981
67982   arg1 = (Dali::Toolkit::Control *)jarg1;
67983   if (!arg1) {
67984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67985     return 0;
67986   }
67987   {
67988     try {
67989       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67990     } catch (std::out_of_range& e) {
67991       {
67992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67993       };
67994     } catch (std::exception& e) {
67995       {
67996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67997       };
67998     } catch (Dali::DaliException e) {
67999       {
68000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68001       };
68002     } catch (...) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68005       };
68006     }
68007   }
68008
68009   jresult = (void *)result;
68010   return jresult;
68011 }
68012
68013
68014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68015   unsigned int jresult ;
68016   Dali::Toolkit::Control *arg1 = 0 ;
68017   bool result;
68018
68019   arg1 = (Dali::Toolkit::Control *)jarg1;
68020   if (!arg1) {
68021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68022     return 0;
68023   }
68024   {
68025     try {
68026       result = (bool)arg1->IsResourceReady();
68027     } catch (std::out_of_range& e) {
68028       {
68029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68030       };
68031     } catch (std::exception& e) {
68032       {
68033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68034       };
68035     } catch (Dali::DaliException e) {
68036       {
68037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68038       };
68039     } catch (...) {
68040       {
68041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68042       };
68043     }
68044   }
68045
68046   jresult = result;
68047   return jresult;
68048 }
68049
68050
68051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68052   void * jresult ;
68053   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68054
68055   {
68056     try {
68057       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68065       };
68066     } catch (Dali::DaliException e) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68069       };
68070     } catch (...) {
68071       {
68072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68073       };
68074     }
68075   }
68076
68077   jresult = (void *)result;
68078   return jresult;
68079 }
68080
68081
68082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68083   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68084
68085   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68086   {
68087     try {
68088       delete arg1;
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68096       };
68097     } catch (Dali::DaliException e) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68104       };
68105     }
68106   }
68107
68108 }
68109
68110
68111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68112   void * jresult ;
68113   Dali::Toolkit::KeyInputFocusManager result;
68114
68115   {
68116     try {
68117       result = Dali::Toolkit::KeyInputFocusManager::Get();
68118     } catch (std::out_of_range& e) {
68119       {
68120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68121       };
68122     } catch (std::exception& e) {
68123       {
68124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (Dali::DaliException e) {
68127       {
68128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68133       };
68134     }
68135   }
68136
68137   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68138   return jresult;
68139 }
68140
68141
68142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68143   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68144   Dali::Toolkit::Control arg2 ;
68145   Dali::Toolkit::Control *argp2 ;
68146
68147   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68148   argp2 = (Dali::Toolkit::Control *)jarg2;
68149   if (!argp2) {
68150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68151     return ;
68152   }
68153   arg2 = *argp2;
68154   {
68155     try {
68156       (arg1)->SetFocus(arg2);
68157     } catch (std::out_of_range& e) {
68158       {
68159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68160       };
68161     } catch (std::exception& e) {
68162       {
68163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68164       };
68165     } catch (Dali::DaliException e) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68172       };
68173     }
68174   }
68175
68176 }
68177
68178
68179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68180   void * jresult ;
68181   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68182   Dali::Toolkit::Control result;
68183
68184   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68185   {
68186     try {
68187       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68188     } catch (std::out_of_range& e) {
68189       {
68190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (std::exception& e) {
68193       {
68194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68195       };
68196     } catch (Dali::DaliException e) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68199       };
68200     } catch (...) {
68201       {
68202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68203       };
68204     }
68205   }
68206
68207   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68213   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68214   Dali::Toolkit::Control arg2 ;
68215   Dali::Toolkit::Control *argp2 ;
68216
68217   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68218   argp2 = (Dali::Toolkit::Control *)jarg2;
68219   if (!argp2) {
68220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68221     return ;
68222   }
68223   arg2 = *argp2;
68224   {
68225     try {
68226       (arg1)->RemoveFocus(arg2);
68227     } catch (std::out_of_range& e) {
68228       {
68229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68230       };
68231     } catch (std::exception& e) {
68232       {
68233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68234       };
68235     } catch (Dali::DaliException e) {
68236       {
68237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68242       };
68243     }
68244   }
68245
68246 }
68247
68248
68249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68250   void * jresult ;
68251   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68252   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68253
68254   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68255   {
68256     try {
68257       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68258     } catch (std::out_of_range& e) {
68259       {
68260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (std::exception& e) {
68263       {
68264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68265       };
68266     } catch (Dali::DaliException e) {
68267       {
68268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68269       };
68270     } catch (...) {
68271       {
68272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68273       };
68274     }
68275   }
68276
68277   jresult = (void *)result;
68278   return jresult;
68279 }
68280
68281
68282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68283   void * jresult ;
68284   Dali::Toolkit::Alignment::Padding *result = 0 ;
68285
68286   {
68287     try {
68288       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (Dali::DaliException e) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68300       };
68301     } catch (...) {
68302       {
68303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68304       };
68305     }
68306   }
68307
68308   jresult = (void *)result;
68309   return jresult;
68310 }
68311
68312
68313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68314   void * jresult ;
68315   float arg1 ;
68316   float arg2 ;
68317   float arg3 ;
68318   float arg4 ;
68319   Dali::Toolkit::Alignment::Padding *result = 0 ;
68320
68321   arg1 = (float)jarg1;
68322   arg2 = (float)jarg2;
68323   arg3 = (float)jarg3;
68324   arg4 = (float)jarg4;
68325   {
68326     try {
68327       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68328     } catch (std::out_of_range& e) {
68329       {
68330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68331       };
68332     } catch (std::exception& e) {
68333       {
68334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68335       };
68336     } catch (Dali::DaliException e) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68339       };
68340     } catch (...) {
68341       {
68342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68343       };
68344     }
68345   }
68346
68347   jresult = (void *)result;
68348   return jresult;
68349 }
68350
68351
68352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68353   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68354   float arg2 ;
68355
68356   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68357   arg2 = (float)jarg2;
68358   if (arg1) (arg1)->left = arg2;
68359 }
68360
68361
68362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68363   float jresult ;
68364   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68365   float result;
68366
68367   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68368   result = (float) ((arg1)->left);
68369   jresult = result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68375   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68376   float arg2 ;
68377
68378   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68379   arg2 = (float)jarg2;
68380   if (arg1) (arg1)->right = arg2;
68381 }
68382
68383
68384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68385   float jresult ;
68386   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68387   float result;
68388
68389   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68390   result = (float) ((arg1)->right);
68391   jresult = result;
68392   return jresult;
68393 }
68394
68395
68396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68397   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68398   float arg2 ;
68399
68400   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68401   arg2 = (float)jarg2;
68402   if (arg1) (arg1)->top = arg2;
68403 }
68404
68405
68406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68407   float jresult ;
68408   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68409   float result;
68410
68411   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68412   result = (float) ((arg1)->top);
68413   jresult = result;
68414   return jresult;
68415 }
68416
68417
68418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68419   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68420   float arg2 ;
68421
68422   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68423   arg2 = (float)jarg2;
68424   if (arg1) (arg1)->bottom = arg2;
68425 }
68426
68427
68428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68429   float jresult ;
68430   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68431   float result;
68432
68433   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68434   result = (float) ((arg1)->bottom);
68435   jresult = result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68441   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68442
68443   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68444   {
68445     try {
68446       delete arg1;
68447     } catch (std::out_of_range& e) {
68448       {
68449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68450       };
68451     } catch (std::exception& e) {
68452       {
68453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68454       };
68455     } catch (Dali::DaliException e) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68458       };
68459     } catch (...) {
68460       {
68461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68462       };
68463     }
68464   }
68465
68466 }
68467
68468
68469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68470   void * jresult ;
68471   Dali::Toolkit::Alignment *result = 0 ;
68472
68473   {
68474     try {
68475       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68476     } catch (std::out_of_range& e) {
68477       {
68478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68479       };
68480     } catch (std::exception& e) {
68481       {
68482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (Dali::DaliException e) {
68485       {
68486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68487       };
68488     } catch (...) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68491       };
68492     }
68493   }
68494
68495   jresult = (void *)result;
68496   return jresult;
68497 }
68498
68499
68500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68501   void * jresult ;
68502   Dali::Toolkit::Alignment::Type arg1 ;
68503   Dali::Toolkit::Alignment::Type arg2 ;
68504   Dali::Toolkit::Alignment result;
68505
68506   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68507   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68508   {
68509     try {
68510       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68511     } catch (std::out_of_range& e) {
68512       {
68513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68514       };
68515     } catch (std::exception& e) {
68516       {
68517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (Dali::DaliException e) {
68520       {
68521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68522       };
68523     } catch (...) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68526       };
68527     }
68528   }
68529
68530   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68531   return jresult;
68532 }
68533
68534
68535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68536   void * jresult ;
68537   Dali::Toolkit::Alignment::Type arg1 ;
68538   Dali::Toolkit::Alignment result;
68539
68540   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68541   {
68542     try {
68543       result = Dali::Toolkit::Alignment::New(arg1);
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68551       };
68552     } catch (Dali::DaliException e) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68555       };
68556     } catch (...) {
68557       {
68558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68559       };
68560     }
68561   }
68562
68563   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68564   return jresult;
68565 }
68566
68567
68568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68569   void * jresult ;
68570   Dali::Toolkit::Alignment result;
68571
68572   {
68573     try {
68574       result = Dali::Toolkit::Alignment::New();
68575     } catch (std::out_of_range& e) {
68576       {
68577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68578       };
68579     } catch (std::exception& e) {
68580       {
68581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68582       };
68583     } catch (Dali::DaliException e) {
68584       {
68585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68590       };
68591     }
68592   }
68593
68594   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68595   return jresult;
68596 }
68597
68598
68599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68600   void * jresult ;
68601   Dali::Toolkit::Alignment *arg1 = 0 ;
68602   Dali::Toolkit::Alignment *result = 0 ;
68603
68604   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68605   if (!arg1) {
68606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68607     return 0;
68608   }
68609   {
68610     try {
68611       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68612     } catch (std::out_of_range& e) {
68613       {
68614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68615       };
68616     } catch (std::exception& e) {
68617       {
68618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (Dali::DaliException e) {
68621       {
68622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68623       };
68624     } catch (...) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68627       };
68628     }
68629   }
68630
68631   jresult = (void *)result;
68632   return jresult;
68633 }
68634
68635
68636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68637   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68638
68639   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68640   {
68641     try {
68642       delete arg1;
68643     } catch (std::out_of_range& e) {
68644       {
68645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68646       };
68647     } catch (std::exception& e) {
68648       {
68649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68650       };
68651     } catch (Dali::DaliException e) {
68652       {
68653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68654       };
68655     } catch (...) {
68656       {
68657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68658       };
68659     }
68660   }
68661
68662 }
68663
68664
68665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68666   void * jresult ;
68667   Dali::BaseHandle arg1 ;
68668   Dali::BaseHandle *argp1 ;
68669   Dali::Toolkit::Alignment result;
68670
68671   argp1 = (Dali::BaseHandle *)jarg1;
68672   if (!argp1) {
68673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68674     return 0;
68675   }
68676   arg1 = *argp1;
68677   {
68678     try {
68679       result = Dali::Toolkit::Alignment::DownCast(arg1);
68680     } catch (std::out_of_range& e) {
68681       {
68682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68683       };
68684     } catch (std::exception& e) {
68685       {
68686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68687       };
68688     } catch (Dali::DaliException e) {
68689       {
68690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68691       };
68692     } catch (...) {
68693       {
68694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68695       };
68696     }
68697   }
68698
68699   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68700   return jresult;
68701 }
68702
68703
68704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68705   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68706   Dali::Toolkit::Alignment::Type arg2 ;
68707
68708   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68709   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68710   {
68711     try {
68712       (arg1)->SetAlignmentType(arg2);
68713     } catch (std::out_of_range& e) {
68714       {
68715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68716       };
68717     } catch (std::exception& e) {
68718       {
68719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68720       };
68721     } catch (Dali::DaliException e) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68724       };
68725     } catch (...) {
68726       {
68727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68728       };
68729     }
68730   }
68731
68732 }
68733
68734
68735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68736   int jresult ;
68737   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68738   Dali::Toolkit::Alignment::Type result;
68739
68740   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68741   {
68742     try {
68743       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68744     } catch (std::out_of_range& e) {
68745       {
68746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68747       };
68748     } catch (std::exception& e) {
68749       {
68750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68751       };
68752     } catch (Dali::DaliException e) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68759       };
68760     }
68761   }
68762
68763   jresult = (int)result;
68764   return jresult;
68765 }
68766
68767
68768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68769   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68770   Dali::Toolkit::Alignment::Scaling arg2 ;
68771
68772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68773   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68774   {
68775     try {
68776       (arg1)->SetScaling(arg2);
68777     } catch (std::out_of_range& e) {
68778       {
68779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68780       };
68781     } catch (std::exception& e) {
68782       {
68783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68784       };
68785     } catch (Dali::DaliException e) {
68786       {
68787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68788       };
68789     } catch (...) {
68790       {
68791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68792       };
68793     }
68794   }
68795
68796 }
68797
68798
68799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68800   int jresult ;
68801   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68802   Dali::Toolkit::Alignment::Scaling result;
68803
68804   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68805   {
68806     try {
68807       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68808     } catch (std::out_of_range& e) {
68809       {
68810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68811       };
68812     } catch (std::exception& e) {
68813       {
68814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68815       };
68816     } catch (Dali::DaliException e) {
68817       {
68818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68819       };
68820     } catch (...) {
68821       {
68822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68823       };
68824     }
68825   }
68826
68827   jresult = (int)result;
68828   return jresult;
68829 }
68830
68831
68832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68833   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68834   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68835
68836   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68837   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68838   if (!arg2) {
68839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68840     return ;
68841   }
68842   {
68843     try {
68844       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (Dali::DaliException e) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68856       };
68857     } catch (...) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68860       };
68861     }
68862   }
68863
68864 }
68865
68866
68867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68868   void * jresult ;
68869   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68870   Dali::Toolkit::Alignment::Padding *result = 0 ;
68871
68872   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68873   {
68874     try {
68875       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (Dali::DaliException e) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68887       };
68888     } catch (...) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68891       };
68892     }
68893   }
68894
68895   jresult = (void *)result;
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68901   void * jresult ;
68902   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68903   Dali::Toolkit::Alignment *arg2 = 0 ;
68904   Dali::Toolkit::Alignment *result = 0 ;
68905
68906   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68907   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68908   if (!arg2) {
68909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68910     return 0;
68911   }
68912   {
68913     try {
68914       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68915     } catch (std::out_of_range& e) {
68916       {
68917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68918       };
68919     } catch (std::exception& e) {
68920       {
68921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68922       };
68923     } catch (Dali::DaliException e) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68926       };
68927     } catch (...) {
68928       {
68929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68930       };
68931     }
68932   }
68933
68934   jresult = (void *)result;
68935   return jresult;
68936 }
68937
68938
68939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68940   int jresult ;
68941   int result;
68942
68943   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68944   jresult = (int)result;
68945   return jresult;
68946 }
68947
68948
68949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68950   int jresult ;
68951   int result;
68952
68953   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68954   jresult = (int)result;
68955   return jresult;
68956 }
68957
68958
68959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68960   int jresult ;
68961   int result;
68962
68963   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68964   jresult = (int)result;
68965   return jresult;
68966 }
68967
68968
68969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68970   int jresult ;
68971   int result;
68972
68973   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68974   jresult = (int)result;
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68980   int jresult ;
68981   int result;
68982
68983   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68984   jresult = (int)result;
68985   return jresult;
68986 }
68987
68988
68989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68990   int jresult ;
68991   int result;
68992
68993   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68994   jresult = (int)result;
68995   return jresult;
68996 }
68997
68998
68999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69000   int jresult ;
69001   int result;
69002
69003   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69004   jresult = (int)result;
69005   return jresult;
69006 }
69007
69008
69009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69010   int jresult ;
69011   int result;
69012
69013   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69014   jresult = (int)result;
69015   return jresult;
69016 }
69017
69018
69019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69020   int jresult ;
69021   int result;
69022
69023   result = (int)Dali::Toolkit::Button::Property::LABEL;
69024   jresult = (int)result;
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69030   int jresult ;
69031   int result;
69032
69033   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69034   jresult = (int)result;
69035   return jresult;
69036 }
69037
69038
69039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69040   void * jresult ;
69041   Dali::Toolkit::Button::Property *result = 0 ;
69042
69043   {
69044     try {
69045       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
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_delete_Button_Property(void * jarg1) {
69071   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69072
69073   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69074   {
69075     try {
69076       delete arg1;
69077     } catch (std::out_of_range& e) {
69078       {
69079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69080       };
69081     } catch (std::exception& e) {
69082       {
69083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69084       };
69085     } catch (Dali::DaliException e) {
69086       {
69087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69088       };
69089     } catch (...) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69092       };
69093     }
69094   }
69095
69096 }
69097
69098
69099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69100   void * jresult ;
69101   Dali::Toolkit::Button *result = 0 ;
69102
69103   {
69104     try {
69105       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69106     } catch (std::out_of_range& e) {
69107       {
69108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (std::exception& e) {
69111       {
69112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69113       };
69114     } catch (Dali::DaliException e) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69117       };
69118     } catch (...) {
69119       {
69120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69121       };
69122     }
69123   }
69124
69125   jresult = (void *)result;
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69131   void * jresult ;
69132   Dali::Toolkit::Button *arg1 = 0 ;
69133   Dali::Toolkit::Button *result = 0 ;
69134
69135   arg1 = (Dali::Toolkit::Button *)jarg1;
69136   if (!arg1) {
69137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69138     return 0;
69139   }
69140   {
69141     try {
69142       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69143     } catch (std::out_of_range& e) {
69144       {
69145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69146       };
69147     } catch (std::exception& e) {
69148       {
69149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69150       };
69151     } catch (Dali::DaliException e) {
69152       {
69153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69158       };
69159     }
69160   }
69161
69162   jresult = (void *)result;
69163   return jresult;
69164 }
69165
69166
69167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69168   void * jresult ;
69169   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69170   Dali::Toolkit::Button *arg2 = 0 ;
69171   Dali::Toolkit::Button *result = 0 ;
69172
69173   arg1 = (Dali::Toolkit::Button *)jarg1;
69174   arg2 = (Dali::Toolkit::Button *)jarg2;
69175   if (!arg2) {
69176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69177     return 0;
69178   }
69179   {
69180     try {
69181       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69182     } catch (std::out_of_range& e) {
69183       {
69184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69185       };
69186     } catch (std::exception& e) {
69187       {
69188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69189       };
69190     } catch (Dali::DaliException e) {
69191       {
69192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69193       };
69194     } catch (...) {
69195       {
69196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69197       };
69198     }
69199   }
69200
69201   jresult = (void *)result;
69202   return jresult;
69203 }
69204
69205
69206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69207   void * jresult ;
69208   Dali::BaseHandle arg1 ;
69209   Dali::BaseHandle *argp1 ;
69210   Dali::Toolkit::Button result;
69211
69212   argp1 = (Dali::BaseHandle *)jarg1;
69213   if (!argp1) {
69214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69215     return 0;
69216   }
69217   arg1 = *argp1;
69218   {
69219     try {
69220       result = Dali::Toolkit::Button::DownCast(arg1);
69221     } catch (std::out_of_range& e) {
69222       {
69223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69224       };
69225     } catch (std::exception& e) {
69226       {
69227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69228       };
69229     } catch (Dali::DaliException e) {
69230       {
69231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69232       };
69233     } catch (...) {
69234       {
69235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69236       };
69237     }
69238   }
69239
69240   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69241   return jresult;
69242 }
69243
69244
69245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69246   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69247
69248   arg1 = (Dali::Toolkit::Button *)jarg1;
69249   {
69250     try {
69251       delete arg1;
69252     } catch (std::out_of_range& e) {
69253       {
69254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69255       };
69256     } catch (std::exception& e) {
69257       {
69258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (Dali::DaliException e) {
69261       {
69262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69263       };
69264     } catch (...) {
69265       {
69266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69267       };
69268     }
69269   }
69270
69271 }
69272
69273
69274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69275   unsigned int jresult ;
69276   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69277   bool result;
69278
69279   arg1 = (Dali::Toolkit::Button *)jarg1;
69280   {
69281     try {
69282       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
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 = result;
69303   return jresult;
69304 }
69305
69306
69307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69308   unsigned int jresult ;
69309   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69310   bool result;
69311
69312   arg1 = (Dali::Toolkit::Button *)jarg1;
69313   {
69314     try {
69315       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69316     } catch (std::out_of_range& e) {
69317       {
69318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69319       };
69320     } catch (std::exception& e) {
69321       {
69322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69323       };
69324     } catch (Dali::DaliException e) {
69325       {
69326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69327       };
69328     } catch (...) {
69329       {
69330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69331       };
69332     }
69333   }
69334
69335   jresult = result;
69336   return jresult;
69337 }
69338
69339
69340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69341   float jresult ;
69342   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69343   float result;
69344
69345   arg1 = (Dali::Toolkit::Button *)jarg1;
69346   {
69347     try {
69348       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69349     } catch (std::out_of_range& e) {
69350       {
69351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69352       };
69353     } catch (std::exception& e) {
69354       {
69355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69356       };
69357     } catch (Dali::DaliException e) {
69358       {
69359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69360       };
69361     } catch (...) {
69362       {
69363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69364       };
69365     }
69366   }
69367
69368   jresult = result;
69369   return jresult;
69370 }
69371
69372
69373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69374   float jresult ;
69375   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69376   float result;
69377
69378   arg1 = (Dali::Toolkit::Button *)jarg1;
69379   {
69380     try {
69381       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69382     } catch (std::out_of_range& e) {
69383       {
69384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69385       };
69386     } catch (std::exception& e) {
69387       {
69388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69389       };
69390     } catch (Dali::DaliException e) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69393       };
69394     } catch (...) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69397       };
69398     }
69399   }
69400
69401   jresult = result;
69402   return jresult;
69403 }
69404
69405
69406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69407   unsigned int jresult ;
69408   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69409   bool result;
69410
69411   arg1 = (Dali::Toolkit::Button *)jarg1;
69412   {
69413     try {
69414       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69415     } catch (std::out_of_range& e) {
69416       {
69417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69418       };
69419     } catch (std::exception& e) {
69420       {
69421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69422       };
69423     } catch (Dali::DaliException e) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69426       };
69427     } catch (...) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69430       };
69431     }
69432   }
69433
69434   jresult = result;
69435   return jresult;
69436 }
69437
69438
69439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69440   unsigned int jresult ;
69441   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69442   bool result;
69443
69444   arg1 = (Dali::Toolkit::Button *)jarg1;
69445   {
69446     try {
69447       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69448     } catch (std::out_of_range& e) {
69449       {
69450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69451       };
69452     } catch (std::exception& e) {
69453       {
69454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (Dali::DaliException e) {
69457       {
69458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69459       };
69460     } catch (...) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69463       };
69464     }
69465   }
69466
69467   jresult = result;
69468   return jresult;
69469 }
69470
69471
69472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69473   float jresult ;
69474   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69475   float result;
69476
69477   arg1 = (Dali::Toolkit::Button *)jarg1;
69478   {
69479     try {
69480       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69481     } catch (std::out_of_range& e) {
69482       {
69483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (std::exception& e) {
69486       {
69487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69488       };
69489     } catch (Dali::DaliException e) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69492       };
69493     } catch (...) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69496       };
69497     }
69498   }
69499
69500   jresult = result;
69501   return jresult;
69502 }
69503
69504
69505 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69506   char * jresult ;
69507   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69508   std::string result;
69509
69510   arg1 = (Dali::Toolkit::Button *)jarg1;
69511   {
69512     try {
69513       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69514     } catch (std::out_of_range& e) {
69515       {
69516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (std::exception& e) {
69519       {
69520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69521       };
69522     } catch (Dali::DaliException e) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69529       };
69530     }
69531   }
69532
69533   jresult = SWIG_csharp_string_callback((&result)->c_str());
69534   return jresult;
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69539   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69540   Dali::Actor arg2 ;
69541   Dali::Actor *argp2 ;
69542
69543   arg1 = (Dali::Toolkit::Button *)jarg1;
69544   argp2 = (Dali::Actor *)jarg2;
69545   if (!argp2) {
69546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69547     return ;
69548   }
69549   arg2 = *argp2;
69550   {
69551     try {
69552       (arg1)->SetLabel(arg2);
69553     } catch (std::out_of_range& e) {
69554       {
69555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69556       };
69557     } catch (std::exception& e) {
69558       {
69559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69560       };
69561     } catch (Dali::DaliException e) {
69562       {
69563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69564       };
69565     } catch (...) {
69566       {
69567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69568       };
69569     }
69570   }
69571
69572 }
69573
69574
69575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69576   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69577   Dali::Image arg2 ;
69578   Dali::Image *argp2 ;
69579
69580   arg1 = (Dali::Toolkit::Button *)jarg1;
69581   argp2 = (Dali::Image *)jarg2;
69582   if (!argp2) {
69583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69584     return ;
69585   }
69586   arg2 = *argp2;
69587   {
69588     try {
69589       (arg1)->SetButtonImage(arg2);
69590     } catch (std::out_of_range& e) {
69591       {
69592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69593       };
69594     } catch (std::exception& e) {
69595       {
69596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69597       };
69598     } catch (Dali::DaliException e) {
69599       {
69600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69601       };
69602     } catch (...) {
69603       {
69604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69605       };
69606     }
69607   }
69608
69609 }
69610
69611
69612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69613   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69614   Dali::Image arg2 ;
69615   Dali::Image *argp2 ;
69616
69617   arg1 = (Dali::Toolkit::Button *)jarg1;
69618   argp2 = (Dali::Image *)jarg2;
69619   if (!argp2) {
69620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69621     return ;
69622   }
69623   arg2 = *argp2;
69624   {
69625     try {
69626       (arg1)->SetSelectedImage(arg2);
69627     } catch (std::out_of_range& e) {
69628       {
69629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (std::exception& e) {
69632       {
69633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69634       };
69635     } catch (Dali::DaliException e) {
69636       {
69637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69638       };
69639     } catch (...) {
69640       {
69641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69642       };
69643     }
69644   }
69645
69646 }
69647
69648
69649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69650   void * jresult ;
69651   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69652   Dali::Actor result;
69653
69654   arg1 = (Dali::Toolkit::Button *)jarg1;
69655   {
69656     try {
69657       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69658     } catch (std::out_of_range& e) {
69659       {
69660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69661       };
69662     } catch (std::exception& e) {
69663       {
69664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69665       };
69666     } catch (Dali::DaliException e) {
69667       {
69668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69669       };
69670     } catch (...) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69673       };
69674     }
69675   }
69676
69677   jresult = new Dali::Actor((const Dali::Actor &)result);
69678   return jresult;
69679 }
69680
69681
69682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69683   void * jresult ;
69684   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69685   Dali::Actor result;
69686
69687   arg1 = (Dali::Toolkit::Button *)jarg1;
69688   {
69689     try {
69690       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69691     } catch (std::out_of_range& e) {
69692       {
69693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69694       };
69695     } catch (std::exception& e) {
69696       {
69697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69698       };
69699     } catch (Dali::DaliException e) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69702       };
69703     } catch (...) {
69704       {
69705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69706       };
69707     }
69708   }
69709
69710   jresult = new Dali::Actor((const Dali::Actor &)result);
69711   return jresult;
69712 }
69713
69714
69715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69716   void * jresult ;
69717   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69718   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69719
69720   arg1 = (Dali::Toolkit::Button *)jarg1;
69721   {
69722     try {
69723       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69724     } catch (std::out_of_range& e) {
69725       {
69726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69727       };
69728     } catch (std::exception& e) {
69729       {
69730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69731       };
69732     } catch (Dali::DaliException e) {
69733       {
69734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69735       };
69736     } catch (...) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69739       };
69740     }
69741   }
69742
69743   jresult = (void *)result;
69744   return jresult;
69745 }
69746
69747
69748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69749   void * jresult ;
69750   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69751   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69752
69753   arg1 = (Dali::Toolkit::Button *)jarg1;
69754   {
69755     try {
69756       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69757     } catch (std::out_of_range& e) {
69758       {
69759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69760       };
69761     } catch (std::exception& e) {
69762       {
69763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69764       };
69765     } catch (Dali::DaliException e) {
69766       {
69767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69768       };
69769     } catch (...) {
69770       {
69771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69772       };
69773     }
69774   }
69775
69776   jresult = (void *)result;
69777   return jresult;
69778 }
69779
69780
69781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69782   void * jresult ;
69783   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69784   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69785
69786   arg1 = (Dali::Toolkit::Button *)jarg1;
69787   {
69788     try {
69789       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69790     } catch (std::out_of_range& e) {
69791       {
69792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69793       };
69794     } catch (std::exception& e) {
69795       {
69796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69797       };
69798     } catch (Dali::DaliException e) {
69799       {
69800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69801       };
69802     } catch (...) {
69803       {
69804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69805       };
69806     }
69807   }
69808
69809   jresult = (void *)result;
69810   return jresult;
69811 }
69812
69813
69814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69815   void * jresult ;
69816   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69817   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69818
69819   arg1 = (Dali::Toolkit::Button *)jarg1;
69820   {
69821     try {
69822       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69823     } catch (std::out_of_range& e) {
69824       {
69825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69826       };
69827     } catch (std::exception& e) {
69828       {
69829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (Dali::DaliException e) {
69832       {
69833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69834       };
69835     } catch (...) {
69836       {
69837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69838       };
69839     }
69840   }
69841
69842   jresult = (void *)result;
69843   return jresult;
69844 }
69845
69846
69847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69848   void * jresult ;
69849   Dali::Toolkit::CheckBoxButton *result = 0 ;
69850
69851   {
69852     try {
69853       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69854     } catch (std::out_of_range& e) {
69855       {
69856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69857       };
69858     } catch (std::exception& e) {
69859       {
69860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69861       };
69862     } catch (Dali::DaliException e) {
69863       {
69864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69865       };
69866     } catch (...) {
69867       {
69868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69869       };
69870     }
69871   }
69872
69873   jresult = (void *)result;
69874   return jresult;
69875 }
69876
69877
69878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69879   void * jresult ;
69880   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69881   Dali::Toolkit::CheckBoxButton *result = 0 ;
69882
69883   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69884   if (!arg1) {
69885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69886     return 0;
69887   }
69888   {
69889     try {
69890       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69891     } catch (std::out_of_range& e) {
69892       {
69893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69894       };
69895     } catch (std::exception& e) {
69896       {
69897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69898       };
69899     } catch (Dali::DaliException e) {
69900       {
69901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69902       };
69903     } catch (...) {
69904       {
69905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69906       };
69907     }
69908   }
69909
69910   jresult = (void *)result;
69911   return jresult;
69912 }
69913
69914
69915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69916   void * jresult ;
69917   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69918   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69919   Dali::Toolkit::CheckBoxButton *result = 0 ;
69920
69921   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69922   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69923   if (!arg2) {
69924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69925     return 0;
69926   }
69927   {
69928     try {
69929       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69930     } catch (std::out_of_range& e) {
69931       {
69932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69933       };
69934     } catch (std::exception& e) {
69935       {
69936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69937       };
69938     } catch (Dali::DaliException e) {
69939       {
69940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69941       };
69942     } catch (...) {
69943       {
69944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69945       };
69946     }
69947   }
69948
69949   jresult = (void *)result;
69950   return jresult;
69951 }
69952
69953
69954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69955   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69956
69957   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69958   {
69959     try {
69960       delete arg1;
69961     } catch (std::out_of_range& e) {
69962       {
69963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69964       };
69965     } catch (std::exception& e) {
69966       {
69967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69968       };
69969     } catch (Dali::DaliException e) {
69970       {
69971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69972       };
69973     } catch (...) {
69974       {
69975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69976       };
69977     }
69978   }
69979
69980 }
69981
69982
69983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69984   void * jresult ;
69985   Dali::Toolkit::CheckBoxButton result;
69986
69987   {
69988     try {
69989       result = Dali::Toolkit::CheckBoxButton::New();
69990     } catch (std::out_of_range& e) {
69991       {
69992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69993       };
69994     } catch (std::exception& e) {
69995       {
69996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (Dali::DaliException e) {
69999       {
70000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70005       };
70006     }
70007   }
70008
70009   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70010   return jresult;
70011 }
70012
70013
70014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70015   void * jresult ;
70016   Dali::BaseHandle arg1 ;
70017   Dali::BaseHandle *argp1 ;
70018   Dali::Toolkit::CheckBoxButton result;
70019
70020   argp1 = (Dali::BaseHandle *)jarg1;
70021   if (!argp1) {
70022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70023     return 0;
70024   }
70025   arg1 = *argp1;
70026   {
70027     try {
70028       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70029     } catch (std::out_of_range& e) {
70030       {
70031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70032       };
70033     } catch (std::exception& e) {
70034       {
70035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70036       };
70037     } catch (Dali::DaliException e) {
70038       {
70039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70040       };
70041     } catch (...) {
70042       {
70043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70044       };
70045     }
70046   }
70047
70048   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70049   return jresult;
70050 }
70051
70052
70053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70054   int jresult ;
70055   int result;
70056
70057   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70058   jresult = (int)result;
70059   return jresult;
70060 }
70061
70062
70063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70064   int jresult ;
70065   int result;
70066
70067   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70068   jresult = (int)result;
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70074   int jresult ;
70075   int result;
70076
70077   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70078   jresult = (int)result;
70079   return jresult;
70080 }
70081
70082
70083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70084   int jresult ;
70085   int result;
70086
70087   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70088   jresult = (int)result;
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70094   int jresult ;
70095   int result;
70096
70097   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70098   jresult = (int)result;
70099   return jresult;
70100 }
70101
70102
70103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70104   void * jresult ;
70105   Dali::Toolkit::PushButton::Property *result = 0 ;
70106
70107   {
70108     try {
70109       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (Dali::DaliException e) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70121       };
70122     } catch (...) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70125       };
70126     }
70127   }
70128
70129   jresult = (void *)result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70135   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70136
70137   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70138   {
70139     try {
70140       delete arg1;
70141     } catch (std::out_of_range& e) {
70142       {
70143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70144       };
70145     } catch (std::exception& e) {
70146       {
70147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70148       };
70149     } catch (Dali::DaliException e) {
70150       {
70151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70156       };
70157     }
70158   }
70159
70160 }
70161
70162
70163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70164   void * jresult ;
70165   Dali::Toolkit::PushButton *result = 0 ;
70166
70167   {
70168     try {
70169       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70170     } catch (std::out_of_range& e) {
70171       {
70172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70173       };
70174     } catch (std::exception& e) {
70175       {
70176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (Dali::DaliException e) {
70179       {
70180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70181       };
70182     } catch (...) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70185       };
70186     }
70187   }
70188
70189   jresult = (void *)result;
70190   return jresult;
70191 }
70192
70193
70194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70195   void * jresult ;
70196   Dali::Toolkit::PushButton *arg1 = 0 ;
70197   Dali::Toolkit::PushButton *result = 0 ;
70198
70199   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70200   if (!arg1) {
70201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70202     return 0;
70203   }
70204   {
70205     try {
70206       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70207     } catch (std::out_of_range& e) {
70208       {
70209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (std::exception& e) {
70212       {
70213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (Dali::DaliException e) {
70216       {
70217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225
70226   jresult = (void *)result;
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70232   void * jresult ;
70233   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70234   Dali::Toolkit::PushButton *arg2 = 0 ;
70235   Dali::Toolkit::PushButton *result = 0 ;
70236
70237   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70238   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70239   if (!arg2) {
70240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70241     return 0;
70242   }
70243   {
70244     try {
70245       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70253       };
70254     } catch (Dali::DaliException e) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70261       };
70262     }
70263   }
70264
70265   jresult = (void *)result;
70266   return jresult;
70267 }
70268
70269
70270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70271   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70272
70273   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70274   {
70275     try {
70276       delete arg1;
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70284       };
70285     } catch (Dali::DaliException e) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70292       };
70293     }
70294   }
70295
70296 }
70297
70298
70299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70300   void * jresult ;
70301   Dali::Toolkit::PushButton result;
70302
70303   {
70304     try {
70305       result = Dali::Toolkit::PushButton::New();
70306     } catch (std::out_of_range& e) {
70307       {
70308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (std::exception& e) {
70311       {
70312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70313       };
70314     } catch (Dali::DaliException e) {
70315       {
70316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70317       };
70318     } catch (...) {
70319       {
70320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70321       };
70322     }
70323   }
70324
70325   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70331   void * jresult ;
70332   Dali::BaseHandle arg1 ;
70333   Dali::BaseHandle *argp1 ;
70334   Dali::Toolkit::PushButton result;
70335
70336   argp1 = (Dali::BaseHandle *)jarg1;
70337   if (!argp1) {
70338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70339     return 0;
70340   }
70341   arg1 = *argp1;
70342   {
70343     try {
70344       result = Dali::Toolkit::PushButton::DownCast(arg1);
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70352       };
70353     } catch (Dali::DaliException e) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70356       };
70357     } catch (...) {
70358       {
70359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70360       };
70361     }
70362   }
70363
70364   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70365   return jresult;
70366 }
70367
70368
70369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70370   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70371   Dali::Image arg2 ;
70372   Dali::Image *argp2 ;
70373
70374   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70375   argp2 = (Dali::Image *)jarg2;
70376   if (!argp2) {
70377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70378     return ;
70379   }
70380   arg2 = *argp2;
70381   {
70382     try {
70383       (arg1)->SetButtonImage(arg2);
70384     } catch (std::out_of_range& e) {
70385       {
70386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70387       };
70388     } catch (std::exception& e) {
70389       {
70390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70391       };
70392     } catch (Dali::DaliException e) {
70393       {
70394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70395       };
70396     } catch (...) {
70397       {
70398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70399       };
70400     }
70401   }
70402
70403 }
70404
70405
70406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70407   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70408   Dali::Actor arg2 ;
70409   Dali::Actor *argp2 ;
70410
70411   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70412   argp2 = (Dali::Actor *)jarg2;
70413   if (!argp2) {
70414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70415     return ;
70416   }
70417   arg2 = *argp2;
70418   {
70419     try {
70420       (arg1)->SetButtonImage(arg2);
70421     } catch (std::out_of_range& e) {
70422       {
70423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70424       };
70425     } catch (std::exception& e) {
70426       {
70427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70428       };
70429     } catch (Dali::DaliException e) {
70430       {
70431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70432       };
70433     } catch (...) {
70434       {
70435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70436       };
70437     }
70438   }
70439
70440 }
70441
70442
70443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70444   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70445   Dali::Actor arg2 ;
70446   Dali::Actor *argp2 ;
70447
70448   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70449   argp2 = (Dali::Actor *)jarg2;
70450   if (!argp2) {
70451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70452     return ;
70453   }
70454   arg2 = *argp2;
70455   {
70456     try {
70457       (arg1)->SetBackgroundImage(arg2);
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70473       };
70474     }
70475   }
70476
70477 }
70478
70479
70480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70481   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70482   Dali::Image arg2 ;
70483   Dali::Image *argp2 ;
70484
70485   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70486   argp2 = (Dali::Image *)jarg2;
70487   if (!argp2) {
70488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70489     return ;
70490   }
70491   arg2 = *argp2;
70492   {
70493     try {
70494       (arg1)->SetSelectedImage(arg2);
70495     } catch (std::out_of_range& e) {
70496       {
70497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70498       };
70499     } catch (std::exception& e) {
70500       {
70501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70502       };
70503     } catch (Dali::DaliException e) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70506       };
70507     } catch (...) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70510       };
70511     }
70512   }
70513
70514 }
70515
70516
70517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70518   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70519   Dali::Actor arg2 ;
70520   Dali::Actor *argp2 ;
70521
70522   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70523   argp2 = (Dali::Actor *)jarg2;
70524   if (!argp2) {
70525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70526     return ;
70527   }
70528   arg2 = *argp2;
70529   {
70530     try {
70531       (arg1)->SetSelectedImage(arg2);
70532     } catch (std::out_of_range& e) {
70533       {
70534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70535       };
70536     } catch (std::exception& e) {
70537       {
70538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70539       };
70540     } catch (Dali::DaliException e) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70543       };
70544     } catch (...) {
70545       {
70546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70547       };
70548     }
70549   }
70550
70551 }
70552
70553
70554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70555   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70556   Dali::Actor arg2 ;
70557   Dali::Actor *argp2 ;
70558
70559   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70560   argp2 = (Dali::Actor *)jarg2;
70561   if (!argp2) {
70562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70563     return ;
70564   }
70565   arg2 = *argp2;
70566   {
70567     try {
70568       (arg1)->SetSelectedBackgroundImage(arg2);
70569     } catch (std::out_of_range& e) {
70570       {
70571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (std::exception& e) {
70574       {
70575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (Dali::DaliException e) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70584       };
70585     }
70586   }
70587
70588 }
70589
70590
70591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70592   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70593   Dali::Actor arg2 ;
70594   Dali::Actor *argp2 ;
70595
70596   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70597   argp2 = (Dali::Actor *)jarg2;
70598   if (!argp2) {
70599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70600     return ;
70601   }
70602   arg2 = *argp2;
70603   {
70604     try {
70605       (arg1)->SetDisabledBackgroundImage(arg2);
70606     } catch (std::out_of_range& e) {
70607       {
70608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70609       };
70610     } catch (std::exception& e) {
70611       {
70612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70613       };
70614     } catch (Dali::DaliException e) {
70615       {
70616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70617       };
70618     } catch (...) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70621       };
70622     }
70623   }
70624
70625 }
70626
70627
70628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70629   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70630   Dali::Actor arg2 ;
70631   Dali::Actor *argp2 ;
70632
70633   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70634   argp2 = (Dali::Actor *)jarg2;
70635   if (!argp2) {
70636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70637     return ;
70638   }
70639   arg2 = *argp2;
70640   {
70641     try {
70642       (arg1)->SetDisabledImage(arg2);
70643     } catch (std::out_of_range& e) {
70644       {
70645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70646       };
70647     } catch (std::exception& e) {
70648       {
70649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70650       };
70651     } catch (Dali::DaliException e) {
70652       {
70653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70654       };
70655     } catch (...) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70658       };
70659     }
70660   }
70661
70662 }
70663
70664
70665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70666   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70667   Dali::Actor arg2 ;
70668   Dali::Actor *argp2 ;
70669
70670   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70671   argp2 = (Dali::Actor *)jarg2;
70672   if (!argp2) {
70673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70674     return ;
70675   }
70676   arg2 = *argp2;
70677   {
70678     try {
70679       (arg1)->SetDisabledSelectedImage(arg2);
70680     } catch (std::out_of_range& e) {
70681       {
70682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70683       };
70684     } catch (std::exception& e) {
70685       {
70686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70687       };
70688     } catch (Dali::DaliException e) {
70689       {
70690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70691       };
70692     } catch (...) {
70693       {
70694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70695       };
70696     }
70697   }
70698
70699 }
70700
70701
70702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70703   void * jresult ;
70704   Dali::Toolkit::RadioButton *result = 0 ;
70705
70706   {
70707     try {
70708       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70709     } catch (std::out_of_range& e) {
70710       {
70711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70712       };
70713     } catch (std::exception& e) {
70714       {
70715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70716       };
70717     } catch (Dali::DaliException e) {
70718       {
70719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70720       };
70721     } catch (...) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70724       };
70725     }
70726   }
70727
70728   jresult = (void *)result;
70729   return jresult;
70730 }
70731
70732
70733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70734   void * jresult ;
70735   Dali::Toolkit::RadioButton *arg1 = 0 ;
70736   Dali::Toolkit::RadioButton *result = 0 ;
70737
70738   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70739   if (!arg1) {
70740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70741     return 0;
70742   }
70743   {
70744     try {
70745       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70746     } catch (std::out_of_range& e) {
70747       {
70748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70749       };
70750     } catch (std::exception& e) {
70751       {
70752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70753       };
70754     } catch (Dali::DaliException e) {
70755       {
70756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70757       };
70758     } catch (...) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70761       };
70762     }
70763   }
70764
70765   jresult = (void *)result;
70766   return jresult;
70767 }
70768
70769
70770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70771   void * jresult ;
70772   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70773   Dali::Toolkit::RadioButton *arg2 = 0 ;
70774   Dali::Toolkit::RadioButton *result = 0 ;
70775
70776   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70777   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70778   if (!arg2) {
70779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70780     return 0;
70781   }
70782   {
70783     try {
70784       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70785     } catch (std::out_of_range& e) {
70786       {
70787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70788       };
70789     } catch (std::exception& e) {
70790       {
70791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (Dali::DaliException e) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70796       };
70797     } catch (...) {
70798       {
70799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70800       };
70801     }
70802   }
70803
70804   jresult = (void *)result;
70805   return jresult;
70806 }
70807
70808
70809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70810   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70811
70812   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70813   {
70814     try {
70815       delete arg1;
70816     } catch (std::out_of_range& e) {
70817       {
70818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70819       };
70820     } catch (std::exception& e) {
70821       {
70822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70823       };
70824     } catch (Dali::DaliException e) {
70825       {
70826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70827       };
70828     } catch (...) {
70829       {
70830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70831       };
70832     }
70833   }
70834
70835 }
70836
70837
70838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70839   void * jresult ;
70840   Dali::Toolkit::RadioButton result;
70841
70842   {
70843     try {
70844       result = Dali::Toolkit::RadioButton::New();
70845     } catch (std::out_of_range& e) {
70846       {
70847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70848       };
70849     } catch (std::exception& e) {
70850       {
70851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70852       };
70853     } catch (Dali::DaliException e) {
70854       {
70855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70856       };
70857     } catch (...) {
70858       {
70859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70860       };
70861     }
70862   }
70863
70864   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70865   return jresult;
70866 }
70867
70868
70869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70870   void * jresult ;
70871   std::string *arg1 = 0 ;
70872   Dali::Toolkit::RadioButton result;
70873
70874   if (!jarg1) {
70875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70876     return 0;
70877   }
70878   std::string arg1_str(jarg1);
70879   arg1 = &arg1_str;
70880   {
70881     try {
70882       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70883     } catch (std::out_of_range& e) {
70884       {
70885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70886       };
70887     } catch (std::exception& e) {
70888       {
70889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70890       };
70891     } catch (Dali::DaliException e) {
70892       {
70893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70894       };
70895     } catch (...) {
70896       {
70897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70898       };
70899     }
70900   }
70901
70902   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70903
70904   //argout typemap for const std::string&
70905
70906   return jresult;
70907 }
70908
70909
70910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70911   void * jresult ;
70912   Dali::BaseHandle arg1 ;
70913   Dali::BaseHandle *argp1 ;
70914   Dali::Toolkit::RadioButton result;
70915
70916   argp1 = (Dali::BaseHandle *)jarg1;
70917   if (!argp1) {
70918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70919     return 0;
70920   }
70921   arg1 = *argp1;
70922   {
70923     try {
70924       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70925     } catch (std::out_of_range& e) {
70926       {
70927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70928       };
70929     } catch (std::exception& e) {
70930       {
70931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70932       };
70933     } catch (Dali::DaliException e) {
70934       {
70935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70936       };
70937     } catch (...) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70940       };
70941     }
70942   }
70943
70944   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70945   return jresult;
70946 }
70947
70948
70949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70950   int jresult ;
70951   int result;
70952
70953   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70954   jresult = (int)result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70960   int jresult ;
70961   int result;
70962
70963   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70964   jresult = (int)result;
70965   return jresult;
70966 }
70967
70968
70969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70970   int jresult ;
70971   int result;
70972
70973   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70974   jresult = (int)result;
70975   return jresult;
70976 }
70977
70978
70979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70980   int jresult ;
70981   int result;
70982
70983   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70984   jresult = (int)result;
70985   return jresult;
70986 }
70987
70988
70989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70990   int jresult ;
70991   int result;
70992
70993   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70994   jresult = (int)result;
70995   return jresult;
70996 }
70997
70998
70999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71000   int jresult ;
71001   int result;
71002
71003   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71004   jresult = (int)result;
71005   return jresult;
71006 }
71007
71008
71009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71010   void * jresult ;
71011   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71012
71013   {
71014     try {
71015       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71016     } catch (std::out_of_range& e) {
71017       {
71018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71019       };
71020     } catch (std::exception& e) {
71021       {
71022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71023       };
71024     } catch (Dali::DaliException e) {
71025       {
71026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71027       };
71028     } catch (...) {
71029       {
71030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71031       };
71032     }
71033   }
71034
71035   jresult = (void *)result;
71036   return jresult;
71037 }
71038
71039
71040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71041   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71042
71043   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71044   {
71045     try {
71046       delete arg1;
71047     } catch (std::out_of_range& e) {
71048       {
71049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71050       };
71051     } catch (std::exception& e) {
71052       {
71053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71054       };
71055     } catch (Dali::DaliException e) {
71056       {
71057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71058       };
71059     } catch (...) {
71060       {
71061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71062       };
71063     }
71064   }
71065
71066 }
71067
71068
71069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71070   int jresult ;
71071   int result;
71072
71073   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71074   jresult = (int)result;
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71080   int jresult ;
71081   int result;
71082
71083   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71084   jresult = (int)result;
71085   return jresult;
71086 }
71087
71088
71089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71090   int jresult ;
71091   int result;
71092
71093   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71094   jresult = (int)result;
71095   return jresult;
71096 }
71097
71098
71099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71100   void * jresult ;
71101   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71102
71103   {
71104     try {
71105       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71106     } catch (std::out_of_range& e) {
71107       {
71108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71109       };
71110     } catch (std::exception& e) {
71111       {
71112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71113       };
71114     } catch (Dali::DaliException e) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71117       };
71118     } catch (...) {
71119       {
71120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71121       };
71122     }
71123   }
71124
71125   jresult = (void *)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71131   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71132
71133   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71134   {
71135     try {
71136       delete arg1;
71137     } catch (std::out_of_range& e) {
71138       {
71139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71140       };
71141     } catch (std::exception& e) {
71142       {
71143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71144       };
71145     } catch (Dali::DaliException e) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71148       };
71149     } catch (...) {
71150       {
71151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71152       };
71153     }
71154   }
71155
71156 }
71157
71158
71159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71160   void * jresult ;
71161   Dali::Toolkit::FlexContainer *result = 0 ;
71162
71163   {
71164     try {
71165       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71166     } catch (std::out_of_range& e) {
71167       {
71168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71169       };
71170     } catch (std::exception& e) {
71171       {
71172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (Dali::DaliException e) {
71175       {
71176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71177       };
71178     } catch (...) {
71179       {
71180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71181       };
71182     }
71183   }
71184
71185   jresult = (void *)result;
71186   return jresult;
71187 }
71188
71189
71190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71191   void * jresult ;
71192   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71193   Dali::Toolkit::FlexContainer *result = 0 ;
71194
71195   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71196   if (!arg1) {
71197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71198     return 0;
71199   }
71200   {
71201     try {
71202       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (Dali::DaliException e) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71214       };
71215     } catch (...) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71218       };
71219     }
71220   }
71221
71222   jresult = (void *)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71228   void * jresult ;
71229   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71230   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71231   Dali::Toolkit::FlexContainer *result = 0 ;
71232
71233   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71234   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71235   if (!arg2) {
71236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71237     return 0;
71238   }
71239   {
71240     try {
71241       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71242     } catch (std::out_of_range& e) {
71243       {
71244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71245       };
71246     } catch (std::exception& e) {
71247       {
71248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71249       };
71250     } catch (Dali::DaliException e) {
71251       {
71252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71253       };
71254     } catch (...) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71257       };
71258     }
71259   }
71260
71261   jresult = (void *)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71267   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71268
71269   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71270   {
71271     try {
71272       delete arg1;
71273     } catch (std::out_of_range& e) {
71274       {
71275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71276       };
71277     } catch (std::exception& e) {
71278       {
71279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71280       };
71281     } catch (Dali::DaliException e) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71284       };
71285     } catch (...) {
71286       {
71287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71288       };
71289     }
71290   }
71291
71292 }
71293
71294
71295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71296   void * jresult ;
71297   Dali::Toolkit::FlexContainer result;
71298
71299   {
71300     try {
71301       result = Dali::Toolkit::FlexContainer::New();
71302     } catch (std::out_of_range& e) {
71303       {
71304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71305       };
71306     } catch (std::exception& e) {
71307       {
71308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71309       };
71310     } catch (Dali::DaliException e) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71313       };
71314     } catch (...) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71317       };
71318     }
71319   }
71320
71321   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71327   void * jresult ;
71328   Dali::BaseHandle arg1 ;
71329   Dali::BaseHandle *argp1 ;
71330   Dali::Toolkit::FlexContainer result;
71331
71332   argp1 = (Dali::BaseHandle *)jarg1;
71333   if (!argp1) {
71334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71335     return 0;
71336   }
71337   arg1 = *argp1;
71338   {
71339     try {
71340       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71341     } catch (std::out_of_range& e) {
71342       {
71343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71344       };
71345     } catch (std::exception& e) {
71346       {
71347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71348       };
71349     } catch (Dali::DaliException e) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71352       };
71353     } catch (...) {
71354       {
71355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71356       };
71357     }
71358   }
71359
71360   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71361   return jresult;
71362 }
71363
71364
71365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71366   int jresult ;
71367   int result;
71368
71369   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71370   jresult = (int)result;
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71376   int jresult ;
71377   int result;
71378
71379   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71380   jresult = (int)result;
71381   return jresult;
71382 }
71383
71384
71385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71386   int jresult ;
71387   int result;
71388
71389   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71390   jresult = (int)result;
71391   return jresult;
71392 }
71393
71394
71395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71396   int jresult ;
71397   int result;
71398
71399   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71400   jresult = (int)result;
71401   return jresult;
71402 }
71403
71404
71405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71406   void * jresult ;
71407   Dali::Toolkit::ImageView::Property *result = 0 ;
71408
71409   {
71410     try {
71411       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71412     } catch (std::out_of_range& e) {
71413       {
71414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71415       };
71416     } catch (std::exception& e) {
71417       {
71418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71419       };
71420     } catch (Dali::DaliException e) {
71421       {
71422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71423       };
71424     } catch (...) {
71425       {
71426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71427       };
71428     }
71429   }
71430
71431   jresult = (void *)result;
71432   return jresult;
71433 }
71434
71435
71436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71437   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71438
71439   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71440   {
71441     try {
71442       delete arg1;
71443     } catch (std::out_of_range& e) {
71444       {
71445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71446       };
71447     } catch (std::exception& e) {
71448       {
71449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71450       };
71451     } catch (Dali::DaliException e) {
71452       {
71453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71454       };
71455     } catch (...) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71458       };
71459     }
71460   }
71461
71462 }
71463
71464
71465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71466   void * jresult ;
71467   Dali::Toolkit::ImageView *result = 0 ;
71468
71469   {
71470     try {
71471       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71472     } catch (std::out_of_range& e) {
71473       {
71474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71475       };
71476     } catch (std::exception& e) {
71477       {
71478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71479       };
71480     } catch (Dali::DaliException e) {
71481       {
71482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71483       };
71484     } catch (...) {
71485       {
71486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71487       };
71488     }
71489   }
71490
71491   jresult = (void *)result;
71492   return jresult;
71493 }
71494
71495
71496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71497   void * jresult ;
71498   Dali::Toolkit::ImageView result;
71499
71500   {
71501     try {
71502       result = Dali::Toolkit::ImageView::New();
71503     } catch (std::out_of_range& e) {
71504       {
71505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71506       };
71507     } catch (std::exception& e) {
71508       {
71509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71510       };
71511     } catch (Dali::DaliException e) {
71512       {
71513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71518       };
71519     }
71520   }
71521
71522   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71528   void * jresult ;
71529   Dali::Image arg1 ;
71530   Dali::Image *argp1 ;
71531   Dali::Toolkit::ImageView result;
71532
71533   argp1 = (Dali::Image *)jarg1;
71534   if (!argp1) {
71535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71536     return 0;
71537   }
71538   arg1 = *argp1;
71539   {
71540     try {
71541       result = Dali::Toolkit::ImageView::New(arg1);
71542     } catch (std::out_of_range& e) {
71543       {
71544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71545       };
71546     } catch (std::exception& e) {
71547       {
71548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71549       };
71550     } catch (Dali::DaliException e) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71553       };
71554     } catch (...) {
71555       {
71556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71557       };
71558     }
71559   }
71560
71561   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71562   return jresult;
71563 }
71564
71565
71566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71567   void * jresult ;
71568   std::string *arg1 = 0 ;
71569   Dali::Toolkit::ImageView result;
71570
71571   if (!jarg1) {
71572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71573     return 0;
71574   }
71575   std::string arg1_str(jarg1);
71576   arg1 = &arg1_str;
71577   {
71578     try {
71579       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71580     } catch (std::out_of_range& e) {
71581       {
71582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71583       };
71584     } catch (std::exception& e) {
71585       {
71586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71587       };
71588     } catch (Dali::DaliException e) {
71589       {
71590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71591       };
71592     } catch (...) {
71593       {
71594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71595       };
71596     }
71597   }
71598
71599   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71600
71601   //argout typemap for const std::string&
71602
71603   return jresult;
71604 }
71605
71606
71607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71608   void * jresult ;
71609   std::string *arg1 = 0 ;
71610   Dali::ImageDimensions arg2 ;
71611   Dali::ImageDimensions *argp2 ;
71612   Dali::Toolkit::ImageView result;
71613
71614   if (!jarg1) {
71615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71616     return 0;
71617   }
71618   std::string arg1_str(jarg1);
71619   arg1 = &arg1_str;
71620   argp2 = (Dali::ImageDimensions *)jarg2;
71621   if (!argp2) {
71622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71623     return 0;
71624   }
71625   arg2 = *argp2;
71626   {
71627     try {
71628       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71629     } catch (std::out_of_range& e) {
71630       {
71631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71632       };
71633     } catch (std::exception& e) {
71634       {
71635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (Dali::DaliException e) {
71638       {
71639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71640       };
71641     } catch (...) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71644       };
71645     }
71646   }
71647
71648   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71649
71650   //argout typemap for const std::string&
71651
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71657   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71658
71659   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71660   {
71661     try {
71662       delete arg1;
71663     } catch (std::out_of_range& e) {
71664       {
71665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71666       };
71667     } catch (std::exception& e) {
71668       {
71669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71670       };
71671     } catch (Dali::DaliException e) {
71672       {
71673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71674       };
71675     } catch (...) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71678       };
71679     }
71680   }
71681
71682 }
71683
71684
71685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71686   void * jresult ;
71687   Dali::Toolkit::ImageView *arg1 = 0 ;
71688   Dali::Toolkit::ImageView *result = 0 ;
71689
71690   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71691   if (!arg1) {
71692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71693     return 0;
71694   }
71695   {
71696     try {
71697       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71698     } catch (std::out_of_range& e) {
71699       {
71700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71701       };
71702     } catch (std::exception& e) {
71703       {
71704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71705       };
71706     } catch (Dali::DaliException e) {
71707       {
71708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71709       };
71710     } catch (...) {
71711       {
71712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71713       };
71714     }
71715   }
71716
71717   jresult = (void *)result;
71718   return jresult;
71719 }
71720
71721
71722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71723   void * jresult ;
71724   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71725   Dali::Toolkit::ImageView *arg2 = 0 ;
71726   Dali::Toolkit::ImageView *result = 0 ;
71727
71728   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71729   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71730   if (!arg2) {
71731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71732     return 0;
71733   }
71734   {
71735     try {
71736       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71737     } catch (std::out_of_range& e) {
71738       {
71739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71740       };
71741     } catch (std::exception& e) {
71742       {
71743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71744       };
71745     } catch (Dali::DaliException e) {
71746       {
71747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71748       };
71749     } catch (...) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71752       };
71753     }
71754   }
71755
71756   jresult = (void *)result;
71757   return jresult;
71758 }
71759
71760
71761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71762   void * jresult ;
71763   Dali::BaseHandle arg1 ;
71764   Dali::BaseHandle *argp1 ;
71765   Dali::Toolkit::ImageView result;
71766
71767   argp1 = (Dali::BaseHandle *)jarg1;
71768   if (!argp1) {
71769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71770     return 0;
71771   }
71772   arg1 = *argp1;
71773   {
71774     try {
71775       result = Dali::Toolkit::ImageView::DownCast(arg1);
71776     } catch (std::out_of_range& e) {
71777       {
71778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71779       };
71780     } catch (std::exception& e) {
71781       {
71782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71783       };
71784     } catch (Dali::DaliException e) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71787       };
71788     } catch (...) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71791       };
71792     }
71793   }
71794
71795   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71796   return jresult;
71797 }
71798
71799
71800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71801   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71802   Dali::Image arg2 ;
71803   Dali::Image *argp2 ;
71804
71805   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71806   argp2 = (Dali::Image *)jarg2;
71807   if (!argp2) {
71808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71809     return ;
71810   }
71811   arg2 = *argp2;
71812   {
71813     try {
71814       (arg1)->SetImage(arg2);
71815     } catch (std::out_of_range& e) {
71816       {
71817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71818       };
71819     } catch (std::exception& e) {
71820       {
71821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71822       };
71823     } catch (Dali::DaliException e) {
71824       {
71825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71826       };
71827     } catch (...) {
71828       {
71829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71830       };
71831     }
71832   }
71833
71834 }
71835
71836
71837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71838   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71839   std::string *arg2 = 0 ;
71840
71841   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71842   if (!jarg2) {
71843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71844     return ;
71845   }
71846   std::string arg2_str(jarg2);
71847   arg2 = &arg2_str;
71848   {
71849     try {
71850       (arg1)->SetImage((std::string const &)*arg2);
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71858       };
71859     } catch (Dali::DaliException e) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71862       };
71863     } catch (...) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71866       };
71867     }
71868   }
71869
71870
71871   //argout typemap for const std::string&
71872
71873 }
71874
71875
71876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71877   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71878   std::string *arg2 = 0 ;
71879   Dali::ImageDimensions arg3 ;
71880   Dali::ImageDimensions *argp3 ;
71881
71882   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71883   if (!jarg2) {
71884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71885     return ;
71886   }
71887   std::string arg2_str(jarg2);
71888   arg2 = &arg2_str;
71889   argp3 = (Dali::ImageDimensions *)jarg3;
71890   if (!argp3) {
71891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71892     return ;
71893   }
71894   arg3 = *argp3;
71895   {
71896     try {
71897       (arg1)->SetImage((std::string const &)*arg2,arg3);
71898     } catch (std::out_of_range& e) {
71899       {
71900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71901       };
71902     } catch (std::exception& e) {
71903       {
71904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71905       };
71906     } catch (Dali::DaliException e) {
71907       {
71908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71909       };
71910     } catch (...) {
71911       {
71912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71913       };
71914     }
71915   }
71916
71917
71918   //argout typemap for const std::string&
71919
71920 }
71921
71922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71923   void * jresult ;
71924   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71925   Dali::Image result;
71926
71927   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71928   {
71929     try {
71930       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = new Dali::Image((const Dali::Image &)result);
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71956   int jresult ;
71957   int result;
71958
71959   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71960   jresult = (int)result;
71961   return jresult;
71962 }
71963
71964
71965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71966   int jresult ;
71967   int result;
71968
71969   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71970   jresult = (int)result;
71971   return jresult;
71972 }
71973
71974
71975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71976   int jresult ;
71977   int result;
71978
71979   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71980   jresult = (int)result;
71981   return jresult;
71982 }
71983
71984
71985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71986   int jresult ;
71987   int result;
71988
71989   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71990   jresult = (int)result;
71991   return jresult;
71992 }
71993
71994
71995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71996   int jresult ;
71997   int result;
71998
71999   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72000   jresult = (int)result;
72001   return jresult;
72002 }
72003
72004
72005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72006   int jresult ;
72007   int result;
72008
72009   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72010   jresult = (int)result;
72011   return jresult;
72012 }
72013
72014
72015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72016   int jresult ;
72017   int result;
72018
72019   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72020   jresult = (int)result;
72021   return jresult;
72022 }
72023
72024
72025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72026   int jresult ;
72027   int result;
72028
72029   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72030   jresult = (int)result;
72031   return jresult;
72032 }
72033
72034
72035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72036   void * jresult ;
72037   Dali::Toolkit::Model3dView::Property *result = 0 ;
72038
72039   {
72040     try {
72041       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72042     } catch (std::out_of_range& e) {
72043       {
72044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72045       };
72046     } catch (std::exception& e) {
72047       {
72048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (Dali::DaliException e) {
72051       {
72052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72053       };
72054     } catch (...) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72057       };
72058     }
72059   }
72060
72061   jresult = (void *)result;
72062   return jresult;
72063 }
72064
72065
72066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72067   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72068
72069   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72070   {
72071     try {
72072       delete arg1;
72073     } catch (std::out_of_range& e) {
72074       {
72075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (std::exception& e) {
72078       {
72079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (Dali::DaliException e) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72084       };
72085     } catch (...) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72088       };
72089     }
72090   }
72091
72092 }
72093
72094
72095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72096   void * jresult ;
72097   Dali::Toolkit::Model3dView result;
72098
72099   {
72100     try {
72101       result = Dali::Toolkit::Model3dView::New();
72102     } catch (std::out_of_range& e) {
72103       {
72104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72105       };
72106     } catch (std::exception& e) {
72107       {
72108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (Dali::DaliException e) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72113       };
72114     } catch (...) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72117       };
72118     }
72119   }
72120
72121   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72122   return jresult;
72123 }
72124
72125
72126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72127   void * jresult ;
72128   std::string *arg1 = 0 ;
72129   std::string *arg2 = 0 ;
72130   std::string *arg3 = 0 ;
72131   Dali::Toolkit::Model3dView result;
72132
72133   if (!jarg1) {
72134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72135     return 0;
72136   }
72137   std::string arg1_str(jarg1);
72138   arg1 = &arg1_str;
72139   if (!jarg2) {
72140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72141     return 0;
72142   }
72143   std::string arg2_str(jarg2);
72144   arg2 = &arg2_str;
72145   if (!jarg3) {
72146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72147     return 0;
72148   }
72149   std::string arg3_str(jarg3);
72150   arg3 = &arg3_str;
72151   {
72152     try {
72153       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72154     } catch (std::out_of_range& e) {
72155       {
72156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72157       };
72158     } catch (std::exception& e) {
72159       {
72160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72161       };
72162     } catch (Dali::DaliException e) {
72163       {
72164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72165       };
72166     } catch (...) {
72167       {
72168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72169       };
72170     }
72171   }
72172
72173   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72174
72175   //argout typemap for const std::string&
72176
72177
72178   //argout typemap for const std::string&
72179
72180
72181   //argout typemap for const std::string&
72182
72183   return jresult;
72184 }
72185
72186
72187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72188   void * jresult ;
72189   Dali::Toolkit::Model3dView *result = 0 ;
72190
72191   {
72192     try {
72193       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72194     } catch (std::out_of_range& e) {
72195       {
72196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72197       };
72198     } catch (std::exception& e) {
72199       {
72200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72201       };
72202     } catch (Dali::DaliException e) {
72203       {
72204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72209       };
72210     }
72211   }
72212
72213   jresult = (void *)result;
72214   return jresult;
72215 }
72216
72217
72218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72219   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72220
72221   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72222   {
72223     try {
72224       delete arg1;
72225     } catch (std::out_of_range& e) {
72226       {
72227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72228       };
72229     } catch (std::exception& e) {
72230       {
72231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (Dali::DaliException e) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72240       };
72241     }
72242   }
72243
72244 }
72245
72246
72247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72248   void * jresult ;
72249   Dali::Toolkit::Model3dView *arg1 = 0 ;
72250   Dali::Toolkit::Model3dView *result = 0 ;
72251
72252   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72253   if (!arg1) {
72254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72255     return 0;
72256   }
72257   {
72258     try {
72259       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72260     } catch (std::out_of_range& e) {
72261       {
72262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72263       };
72264     } catch (std::exception& e) {
72265       {
72266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72267       };
72268     } catch (Dali::DaliException e) {
72269       {
72270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72271       };
72272     } catch (...) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72275       };
72276     }
72277   }
72278
72279   jresult = (void *)result;
72280   return jresult;
72281 }
72282
72283
72284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72285   void * jresult ;
72286   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72287   Dali::Toolkit::Model3dView *arg2 = 0 ;
72288   Dali::Toolkit::Model3dView *result = 0 ;
72289
72290   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72291   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72292   if (!arg2) {
72293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72294     return 0;
72295   }
72296   {
72297     try {
72298       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72299     } catch (std::out_of_range& e) {
72300       {
72301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72302       };
72303     } catch (std::exception& e) {
72304       {
72305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72306       };
72307     } catch (Dali::DaliException e) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72310       };
72311     } catch (...) {
72312       {
72313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72314       };
72315     }
72316   }
72317
72318   jresult = (void *)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72324   void * jresult ;
72325   Dali::BaseHandle arg1 ;
72326   Dali::BaseHandle *argp1 ;
72327   Dali::Toolkit::Model3dView result;
72328
72329   argp1 = (Dali::BaseHandle *)jarg1;
72330   if (!argp1) {
72331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72332     return 0;
72333   }
72334   arg1 = *argp1;
72335   {
72336     try {
72337       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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 = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72363   int jresult ;
72364   int result;
72365
72366   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72367   jresult = (int)result;
72368   return jresult;
72369 }
72370
72371
72372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72373   int jresult ;
72374   int result;
72375
72376   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72377   jresult = (int)result;
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72383   int jresult ;
72384   int result;
72385
72386   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72387   jresult = (int)result;
72388   return jresult;
72389 }
72390
72391
72392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72393   int jresult ;
72394   int result;
72395
72396   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72397   jresult = (int)result;
72398   return jresult;
72399 }
72400
72401
72402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72403   int jresult ;
72404   int result;
72405
72406   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72407   jresult = (int)result;
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72413   int jresult ;
72414   int result;
72415
72416   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72417   jresult = (int)result;
72418   return jresult;
72419 }
72420
72421
72422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72423   int jresult ;
72424   int result;
72425
72426   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72427   jresult = (int)result;
72428   return jresult;
72429 }
72430
72431
72432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72433   int jresult ;
72434   int result;
72435
72436   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72437   jresult = (int)result;
72438   return jresult;
72439 }
72440
72441
72442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72443   int jresult ;
72444   int result;
72445
72446   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72447   jresult = (int)result;
72448   return jresult;
72449 }
72450
72451
72452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72453   void * jresult ;
72454   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72455
72456   {
72457     try {
72458       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72459     } catch (std::out_of_range& e) {
72460       {
72461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (std::exception& e) {
72464       {
72465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (Dali::DaliException e) {
72468       {
72469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72470       };
72471     } catch (...) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72474       };
72475     }
72476   }
72477
72478   jresult = (void *)result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72484   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72485
72486   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72487   {
72488     try {
72489       delete arg1;
72490     } catch (std::out_of_range& e) {
72491       {
72492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72493       };
72494     } catch (std::exception& e) {
72495       {
72496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72497       };
72498     } catch (Dali::DaliException e) {
72499       {
72500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72501       };
72502     } catch (...) {
72503       {
72504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72505       };
72506     }
72507   }
72508
72509 }
72510
72511
72512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72513   void * jresult ;
72514   Dali::Toolkit::ScrollBar *result = 0 ;
72515
72516   {
72517     try {
72518       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72519     } catch (std::out_of_range& e) {
72520       {
72521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72522       };
72523     } catch (std::exception& e) {
72524       {
72525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72526       };
72527     } catch (Dali::DaliException e) {
72528       {
72529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72530       };
72531     } catch (...) {
72532       {
72533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72534       };
72535     }
72536   }
72537
72538   jresult = (void *)result;
72539   return jresult;
72540 }
72541
72542
72543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72544   void * jresult ;
72545   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72546   Dali::Toolkit::ScrollBar *result = 0 ;
72547
72548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72549   if (!arg1) {
72550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72551     return 0;
72552   }
72553   {
72554     try {
72555       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72556     } catch (std::out_of_range& e) {
72557       {
72558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72559       };
72560     } catch (std::exception& e) {
72561       {
72562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72563       };
72564     } catch (Dali::DaliException e) {
72565       {
72566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72567       };
72568     } catch (...) {
72569       {
72570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72571       };
72572     }
72573   }
72574
72575   jresult = (void *)result;
72576   return jresult;
72577 }
72578
72579
72580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72581   void * jresult ;
72582   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72583   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72584   Dali::Toolkit::ScrollBar *result = 0 ;
72585
72586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72587   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72588   if (!arg2) {
72589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72590     return 0;
72591   }
72592   {
72593     try {
72594       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72595     } catch (std::out_of_range& e) {
72596       {
72597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (std::exception& e) {
72600       {
72601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72602       };
72603     } catch (Dali::DaliException e) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72606       };
72607     } catch (...) {
72608       {
72609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72610       };
72611     }
72612   }
72613
72614   jresult = (void *)result;
72615   return jresult;
72616 }
72617
72618
72619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72621
72622   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72623   {
72624     try {
72625       delete arg1;
72626     } catch (std::out_of_range& e) {
72627       {
72628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72629       };
72630     } catch (std::exception& e) {
72631       {
72632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72633       };
72634     } catch (Dali::DaliException e) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72637       };
72638     } catch (...) {
72639       {
72640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72641       };
72642     }
72643   }
72644
72645 }
72646
72647
72648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72649   void * jresult ;
72650   Dali::Toolkit::ScrollBar::Direction arg1 ;
72651   Dali::Toolkit::ScrollBar result;
72652
72653   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72654   {
72655     try {
72656       result = Dali::Toolkit::ScrollBar::New(arg1);
72657     } catch (std::out_of_range& e) {
72658       {
72659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (std::exception& e) {
72662       {
72663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72664       };
72665     } catch (Dali::DaliException e) {
72666       {
72667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72668       };
72669     } catch (...) {
72670       {
72671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72672       };
72673     }
72674   }
72675
72676   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72677   return jresult;
72678 }
72679
72680
72681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72682   void * jresult ;
72683   Dali::Toolkit::ScrollBar result;
72684
72685   {
72686     try {
72687       result = Dali::Toolkit::ScrollBar::New();
72688     } catch (std::out_of_range& e) {
72689       {
72690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72691       };
72692     } catch (std::exception& e) {
72693       {
72694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72695       };
72696     } catch (Dali::DaliException e) {
72697       {
72698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72699       };
72700     } catch (...) {
72701       {
72702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72703       };
72704     }
72705   }
72706
72707   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72708   return jresult;
72709 }
72710
72711
72712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72713   void * jresult ;
72714   Dali::BaseHandle arg1 ;
72715   Dali::BaseHandle *argp1 ;
72716   Dali::Toolkit::ScrollBar result;
72717
72718   argp1 = (Dali::BaseHandle *)jarg1;
72719   if (!argp1) {
72720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72721     return 0;
72722   }
72723   arg1 = *argp1;
72724   {
72725     try {
72726       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72727     } catch (std::out_of_range& e) {
72728       {
72729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72730       };
72731     } catch (std::exception& e) {
72732       {
72733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72734       };
72735     } catch (Dali::DaliException e) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72738       };
72739     } catch (...) {
72740       {
72741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72742       };
72743     }
72744   }
72745
72746   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72752   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72753   Dali::Handle arg2 ;
72754   Dali::Property::Index arg3 ;
72755   Dali::Property::Index arg4 ;
72756   Dali::Property::Index arg5 ;
72757   Dali::Property::Index arg6 ;
72758   Dali::Handle *argp2 ;
72759
72760   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72761   argp2 = (Dali::Handle *)jarg2;
72762   if (!argp2) {
72763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72764     return ;
72765   }
72766   arg2 = *argp2;
72767   arg3 = (Dali::Property::Index)jarg3;
72768   arg4 = (Dali::Property::Index)jarg4;
72769   arg5 = (Dali::Property::Index)jarg5;
72770   arg6 = (Dali::Property::Index)jarg6;
72771   {
72772     try {
72773       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72774     } catch (std::out_of_range& e) {
72775       {
72776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72777       };
72778     } catch (std::exception& e) {
72779       {
72780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72781       };
72782     } catch (Dali::DaliException e) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72789       };
72790     }
72791   }
72792
72793 }
72794
72795
72796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72798   Dali::Actor arg2 ;
72799   Dali::Actor *argp2 ;
72800
72801   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72802   argp2 = (Dali::Actor *)jarg2;
72803   if (!argp2) {
72804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72805     return ;
72806   }
72807   arg2 = *argp2;
72808   {
72809     try {
72810       (arg1)->SetScrollIndicator(arg2);
72811     } catch (std::out_of_range& e) {
72812       {
72813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72814       };
72815     } catch (std::exception& e) {
72816       {
72817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72818       };
72819     } catch (Dali::DaliException e) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72822       };
72823     } catch (...) {
72824       {
72825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72826       };
72827     }
72828   }
72829
72830 }
72831
72832
72833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72834   void * jresult ;
72835   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72836   Dali::Actor result;
72837
72838   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72839   {
72840     try {
72841       result = (arg1)->GetScrollIndicator();
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (Dali::DaliException e) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72853       };
72854     } catch (...) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72857       };
72858     }
72859   }
72860
72861   jresult = new Dali::Actor((const Dali::Actor &)result);
72862   return jresult;
72863 }
72864
72865
72866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72867   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72868   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72869
72870   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72871   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72872   if (!arg2) {
72873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72874     return ;
72875   }
72876   {
72877     try {
72878       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72879     } catch (std::out_of_range& e) {
72880       {
72881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72882       };
72883     } catch (std::exception& e) {
72884       {
72885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72886       };
72887     } catch (Dali::DaliException e) {
72888       {
72889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72890       };
72891     } catch (...) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72894       };
72895     }
72896   }
72897
72898 }
72899
72900
72901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72902   void * jresult ;
72903   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72904
72905   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72906   {
72907     try {
72908       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()));
72909     } catch (std::out_of_range& e) {
72910       {
72911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72912       };
72913     } catch (std::exception& e) {
72914       {
72915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72916       };
72917     } catch (...) {
72918       {
72919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72920       };
72921     }
72922   }
72923   return jresult;
72924 }
72925
72926
72927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72928   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72929   Dali::Toolkit::ScrollBar::Direction arg2 ;
72930
72931   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72932   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72933   {
72934     try {
72935       (arg1)->SetScrollDirection(arg2);
72936     } catch (std::out_of_range& e) {
72937       {
72938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72939       };
72940     } catch (std::exception& e) {
72941       {
72942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72943       };
72944     } catch (Dali::DaliException e) {
72945       {
72946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72947       };
72948     } catch (...) {
72949       {
72950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72951       };
72952     }
72953   }
72954
72955 }
72956
72957
72958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72959   int jresult ;
72960   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72961   Dali::Toolkit::ScrollBar::Direction result;
72962
72963   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72964   {
72965     try {
72966       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (Dali::DaliException e) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72982       };
72983     }
72984   }
72985
72986   jresult = (int)result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72992   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72993   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72994
72995   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72996   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72997   {
72998     try {
72999       (arg1)->SetIndicatorHeightPolicy(arg2);
73000     } catch (std::out_of_range& e) {
73001       {
73002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73003       };
73004     } catch (std::exception& e) {
73005       {
73006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73007       };
73008     } catch (Dali::DaliException e) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73011       };
73012     } catch (...) {
73013       {
73014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73015       };
73016     }
73017   }
73018
73019 }
73020
73021
73022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73023   int jresult ;
73024   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73025   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73026
73027   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73028   {
73029     try {
73030       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73031     } catch (std::out_of_range& e) {
73032       {
73033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73034       };
73035     } catch (std::exception& e) {
73036       {
73037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73038       };
73039     } catch (Dali::DaliException e) {
73040       {
73041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73042       };
73043     } catch (...) {
73044       {
73045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73046       };
73047     }
73048   }
73049
73050   jresult = (int)result;
73051   return jresult;
73052 }
73053
73054
73055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73056   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73057   float arg2 ;
73058
73059   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73060   arg2 = (float)jarg2;
73061   {
73062     try {
73063       (arg1)->SetIndicatorFixedHeight(arg2);
73064     } catch (std::out_of_range& e) {
73065       {
73066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73067       };
73068     } catch (std::exception& e) {
73069       {
73070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73071       };
73072     } catch (Dali::DaliException e) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73075       };
73076     } catch (...) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73079       };
73080     }
73081   }
73082
73083 }
73084
73085
73086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73087   float jresult ;
73088   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73089   float result;
73090
73091   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73092   {
73093     try {
73094       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73095     } catch (std::out_of_range& e) {
73096       {
73097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73098       };
73099     } catch (std::exception& e) {
73100       {
73101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (Dali::DaliException e) {
73104       {
73105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73106       };
73107     } catch (...) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73110       };
73111     }
73112   }
73113
73114   jresult = result;
73115   return jresult;
73116 }
73117
73118
73119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73120   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73121   float arg2 ;
73122
73123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73124   arg2 = (float)jarg2;
73125   {
73126     try {
73127       (arg1)->SetIndicatorShowDuration(arg2);
73128     } catch (std::out_of_range& e) {
73129       {
73130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73131       };
73132     } catch (std::exception& e) {
73133       {
73134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73135       };
73136     } catch (Dali::DaliException e) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73139       };
73140     } catch (...) {
73141       {
73142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73143       };
73144     }
73145   }
73146
73147 }
73148
73149
73150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73151   float jresult ;
73152   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73153   float result;
73154
73155   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73156   {
73157     try {
73158       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (Dali::DaliException e) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73174       };
73175     }
73176   }
73177
73178   jresult = result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73184   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73185   float arg2 ;
73186
73187   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73188   arg2 = (float)jarg2;
73189   {
73190     try {
73191       (arg1)->SetIndicatorHideDuration(arg2);
73192     } catch (std::out_of_range& e) {
73193       {
73194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73195       };
73196     } catch (std::exception& e) {
73197       {
73198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73199       };
73200     } catch (Dali::DaliException e) {
73201       {
73202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73203       };
73204     } catch (...) {
73205       {
73206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73207       };
73208     }
73209   }
73210
73211 }
73212
73213
73214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73215   float jresult ;
73216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73217   float result;
73218
73219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73220   {
73221     try {
73222       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (Dali::DaliException e) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73238       };
73239     }
73240   }
73241
73242   jresult = result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73249
73250   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73251   {
73252     try {
73253       (arg1)->ShowIndicator();
73254     } catch (std::out_of_range& e) {
73255       {
73256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73257       };
73258     } catch (std::exception& e) {
73259       {
73260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73261       };
73262     } catch (Dali::DaliException e) {
73263       {
73264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73265       };
73266     } catch (...) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73269       };
73270     }
73271   }
73272
73273 }
73274
73275
73276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73278
73279   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73280   {
73281     try {
73282       (arg1)->HideIndicator();
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73290       };
73291     } catch (Dali::DaliException e) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73294       };
73295     } catch (...) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73298       };
73299     }
73300   }
73301
73302 }
73303
73304
73305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73306   void * jresult ;
73307   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73308   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73309
73310   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73311   {
73312     try {
73313       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73314     } catch (std::out_of_range& e) {
73315       {
73316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (std::exception& e) {
73319       {
73320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73321       };
73322     } catch (Dali::DaliException e) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73325       };
73326     } catch (...) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73329       };
73330     }
73331   }
73332
73333   jresult = (void *)result;
73334   return jresult;
73335 }
73336
73337
73338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73339   void * jresult ;
73340   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73341   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73342
73343   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73344   {
73345     try {
73346       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73347     } catch (std::out_of_range& e) {
73348       {
73349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (std::exception& e) {
73352       {
73353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (Dali::DaliException e) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73358       };
73359     } catch (...) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73362       };
73363     }
73364   }
73365
73366   jresult = (void *)result;
73367   return jresult;
73368 }
73369
73370
73371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73372   int jresult ;
73373   int result;
73374
73375   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73376   jresult = (int)result;
73377   return jresult;
73378 }
73379
73380
73381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73382   int jresult ;
73383   int result;
73384
73385   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73386   jresult = (int)result;
73387   return jresult;
73388 }
73389
73390
73391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73392   int jresult ;
73393   int result;
73394
73395   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73396   jresult = (int)result;
73397   return jresult;
73398 }
73399
73400
73401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73402   int jresult ;
73403   int result;
73404
73405   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73406   jresult = (int)result;
73407   return jresult;
73408 }
73409
73410
73411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73412   int jresult ;
73413   int result;
73414
73415   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73416   jresult = (int)result;
73417   return jresult;
73418 }
73419
73420
73421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73422   int jresult ;
73423   int result;
73424
73425   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73426   jresult = (int)result;
73427   return jresult;
73428 }
73429
73430
73431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73432   int jresult ;
73433   int result;
73434
73435   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73436   jresult = (int)result;
73437   return jresult;
73438 }
73439
73440
73441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73442   int jresult ;
73443   int result;
73444
73445   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73446   jresult = (int)result;
73447   return jresult;
73448 }
73449
73450
73451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73452   int jresult ;
73453   int result;
73454
73455   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73456   jresult = (int)result;
73457   return jresult;
73458 }
73459
73460
73461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73462   int jresult ;
73463   int result;
73464
73465   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73466   jresult = (int)result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73472   int jresult ;
73473   int result;
73474
73475   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73476   jresult = (int)result;
73477   return jresult;
73478 }
73479
73480
73481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73482   int jresult ;
73483   int result;
73484
73485   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73486   jresult = (int)result;
73487   return jresult;
73488 }
73489
73490
73491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73492   int jresult ;
73493   int result;
73494
73495   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73496   jresult = (int)result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73502   int jresult ;
73503   int result;
73504
73505   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73506   jresult = (int)result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73512   void * jresult ;
73513   Dali::Toolkit::Scrollable::Property *result = 0 ;
73514
73515   {
73516     try {
73517       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73518     } catch (std::out_of_range& e) {
73519       {
73520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73521       };
73522     } catch (std::exception& e) {
73523       {
73524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73525       };
73526     } catch (Dali::DaliException e) {
73527       {
73528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73529       };
73530     } catch (...) {
73531       {
73532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73533       };
73534     }
73535   }
73536
73537   jresult = (void *)result;
73538   return jresult;
73539 }
73540
73541
73542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73543   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73544
73545   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73546   {
73547     try {
73548       delete arg1;
73549     } catch (std::out_of_range& e) {
73550       {
73551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73552       };
73553     } catch (std::exception& e) {
73554       {
73555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73556       };
73557     } catch (Dali::DaliException e) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73560       };
73561     } catch (...) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73564       };
73565     }
73566   }
73567
73568 }
73569
73570
73571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73572   void * jresult ;
73573   Dali::Toolkit::Scrollable *result = 0 ;
73574
73575   {
73576     try {
73577       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73585       };
73586     } catch (Dali::DaliException e) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73589       };
73590     } catch (...) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73593       };
73594     }
73595   }
73596
73597   jresult = (void *)result;
73598   return jresult;
73599 }
73600
73601
73602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73603   void * jresult ;
73604   Dali::Toolkit::Scrollable *arg1 = 0 ;
73605   Dali::Toolkit::Scrollable *result = 0 ;
73606
73607   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73608   if (!arg1) {
73609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73610     return 0;
73611   }
73612   {
73613     try {
73614       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73615     } catch (std::out_of_range& e) {
73616       {
73617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73618       };
73619     } catch (std::exception& e) {
73620       {
73621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (Dali::DaliException e) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73626       };
73627     } catch (...) {
73628       {
73629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73630       };
73631     }
73632   }
73633
73634   jresult = (void *)result;
73635   return jresult;
73636 }
73637
73638
73639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73640   void * jresult ;
73641   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73642   Dali::Toolkit::Scrollable *arg2 = 0 ;
73643   Dali::Toolkit::Scrollable *result = 0 ;
73644
73645   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73646   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73647   if (!arg2) {
73648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73649     return 0;
73650   }
73651   {
73652     try {
73653       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73654     } catch (std::out_of_range& e) {
73655       {
73656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73657       };
73658     } catch (std::exception& e) {
73659       {
73660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73661       };
73662     } catch (Dali::DaliException e) {
73663       {
73664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73665       };
73666     } catch (...) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73669       };
73670     }
73671   }
73672
73673   jresult = (void *)result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73679   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73680
73681   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73682   {
73683     try {
73684       delete arg1;
73685     } catch (std::out_of_range& e) {
73686       {
73687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73688       };
73689     } catch (std::exception& e) {
73690       {
73691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73692       };
73693     } catch (Dali::DaliException e) {
73694       {
73695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73696       };
73697     } catch (...) {
73698       {
73699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73700       };
73701     }
73702   }
73703
73704 }
73705
73706
73707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73708   void * jresult ;
73709   Dali::BaseHandle arg1 ;
73710   Dali::BaseHandle *argp1 ;
73711   Dali::Toolkit::Scrollable result;
73712
73713   argp1 = (Dali::BaseHandle *)jarg1;
73714   if (!argp1) {
73715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73716     return 0;
73717   }
73718   arg1 = *argp1;
73719   {
73720     try {
73721       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73722     } catch (std::out_of_range& e) {
73723       {
73724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73725       };
73726     } catch (std::exception& e) {
73727       {
73728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73729       };
73730     } catch (Dali::DaliException e) {
73731       {
73732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73737       };
73738     }
73739   }
73740
73741   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73742   return jresult;
73743 }
73744
73745
73746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73747   unsigned int jresult ;
73748   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73749   bool result;
73750
73751   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73752   {
73753     try {
73754       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (Dali::DaliException e) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773
73774   jresult = result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73780   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73781   bool arg2 ;
73782
73783   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73784   arg2 = jarg2 ? true : false;
73785   {
73786     try {
73787       (arg1)->SetOvershootEnabled(arg2);
73788     } catch (std::out_of_range& e) {
73789       {
73790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73791       };
73792     } catch (std::exception& e) {
73793       {
73794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73795       };
73796     } catch (Dali::DaliException e) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73803       };
73804     }
73805   }
73806
73807 }
73808
73809
73810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73811   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73812   Dali::Vector4 *arg2 = 0 ;
73813
73814   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73815   arg2 = (Dali::Vector4 *)jarg2;
73816   if (!arg2) {
73817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73818     return ;
73819   }
73820   {
73821     try {
73822       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73823     } catch (std::out_of_range& e) {
73824       {
73825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73826       };
73827     } catch (std::exception& e) {
73828       {
73829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73830       };
73831     } catch (Dali::DaliException e) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73834       };
73835     } catch (...) {
73836       {
73837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73838       };
73839     }
73840   }
73841
73842 }
73843
73844
73845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73846   void * jresult ;
73847   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73848   Dali::Vector4 result;
73849
73850   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73851   {
73852     try {
73853       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73854     } catch (std::out_of_range& e) {
73855       {
73856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73857       };
73858     } catch (std::exception& e) {
73859       {
73860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73861       };
73862     } catch (Dali::DaliException e) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73865       };
73866     } catch (...) {
73867       {
73868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73869       };
73870     }
73871   }
73872
73873   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73874   return jresult;
73875 }
73876
73877
73878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73879   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73880   float arg2 ;
73881
73882   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73883   arg2 = (float)jarg2;
73884   {
73885     try {
73886       (arg1)->SetOvershootAnimationSpeed(arg2);
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73894       };
73895     } catch (Dali::DaliException e) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73898       };
73899     } catch (...) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73902       };
73903     }
73904   }
73905
73906 }
73907
73908
73909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73910   float jresult ;
73911   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73912   float result;
73913
73914   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73915   {
73916     try {
73917       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73918     } catch (std::out_of_range& e) {
73919       {
73920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73921       };
73922     } catch (std::exception& e) {
73923       {
73924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73925       };
73926     } catch (Dali::DaliException e) {
73927       {
73928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73929       };
73930     } catch (...) {
73931       {
73932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73933       };
73934     }
73935   }
73936
73937   jresult = result;
73938   return jresult;
73939 }
73940
73941
73942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73943   void * jresult ;
73944   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73945   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73946
73947   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73948   {
73949     try {
73950       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73951     } catch (std::out_of_range& e) {
73952       {
73953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73954       };
73955     } catch (std::exception& e) {
73956       {
73957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73958       };
73959     } catch (Dali::DaliException e) {
73960       {
73961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73962       };
73963     } catch (...) {
73964       {
73965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73966       };
73967     }
73968   }
73969
73970   jresult = (void *)result;
73971   return jresult;
73972 }
73973
73974
73975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73976   void * jresult ;
73977   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73978   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73979
73980   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73981   {
73982     try {
73983       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (Dali::DaliException e) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002
74003   jresult = (void *)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74009   void * jresult ;
74010   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74011   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74012
74013   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74014   {
74015     try {
74016       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74017     } catch (std::out_of_range& e) {
74018       {
74019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74020       };
74021     } catch (std::exception& e) {
74022       {
74023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74024       };
74025     } catch (Dali::DaliException e) {
74026       {
74027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74028       };
74029     } catch (...) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74032       };
74033     }
74034   }
74035
74036   jresult = (void *)result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74042   unsigned int jresult ;
74043   Dali::Toolkit::ControlOrientation::Type arg1 ;
74044   bool result;
74045
74046   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74047   {
74048     try {
74049       result = (bool)Dali::Toolkit::IsVertical(arg1);
74050     } catch (std::out_of_range& e) {
74051       {
74052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74053       };
74054     } catch (std::exception& e) {
74055       {
74056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74057       };
74058     } catch (Dali::DaliException e) {
74059       {
74060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74061       };
74062     } catch (...) {
74063       {
74064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74065       };
74066     }
74067   }
74068
74069   jresult = result;
74070   return jresult;
74071 }
74072
74073
74074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74075   unsigned int jresult ;
74076   Dali::Toolkit::ControlOrientation::Type arg1 ;
74077   bool result;
74078
74079   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74080   {
74081     try {
74082       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74083     } catch (std::out_of_range& e) {
74084       {
74085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (std::exception& e) {
74088       {
74089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (Dali::DaliException e) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101
74102   jresult = result;
74103   return jresult;
74104 }
74105
74106
74107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74108   void * jresult ;
74109   unsigned int arg1 ;
74110   unsigned int arg2 ;
74111   Dali::Toolkit::ItemRange *result = 0 ;
74112
74113   arg1 = (unsigned int)jarg1;
74114   arg2 = (unsigned int)jarg2;
74115   {
74116     try {
74117       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74118     } catch (std::out_of_range& e) {
74119       {
74120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74121       };
74122     } catch (std::exception& e) {
74123       {
74124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74125       };
74126     } catch (Dali::DaliException e) {
74127       {
74128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74129       };
74130     } catch (...) {
74131       {
74132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74133       };
74134     }
74135   }
74136
74137   jresult = (void *)result;
74138   return jresult;
74139 }
74140
74141
74142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74143   void * jresult ;
74144   Dali::Toolkit::ItemRange *arg1 = 0 ;
74145   Dali::Toolkit::ItemRange *result = 0 ;
74146
74147   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74148   if (!arg1) {
74149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74150     return 0;
74151   }
74152   {
74153     try {
74154       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74155     } catch (std::out_of_range& e) {
74156       {
74157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74158       };
74159     } catch (std::exception& e) {
74160       {
74161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74162       };
74163     } catch (Dali::DaliException e) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74166       };
74167     } catch (...) {
74168       {
74169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74170       };
74171     }
74172   }
74173
74174   jresult = (void *)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74180   void * jresult ;
74181   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74182   Dali::Toolkit::ItemRange *arg2 = 0 ;
74183   Dali::Toolkit::ItemRange *result = 0 ;
74184
74185   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74186   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74187   if (!arg2) {
74188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74189     return 0;
74190   }
74191   {
74192     try {
74193       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74194     } catch (std::out_of_range& e) {
74195       {
74196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74197       };
74198     } catch (std::exception& e) {
74199       {
74200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74201       };
74202     } catch (Dali::DaliException e) {
74203       {
74204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74205       };
74206     } catch (...) {
74207       {
74208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74209       };
74210     }
74211   }
74212
74213   jresult = (void *)result;
74214   return jresult;
74215 }
74216
74217
74218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74219   unsigned int jresult ;
74220   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74221   unsigned int arg2 ;
74222   bool result;
74223
74224   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74225   arg2 = (unsigned int)jarg2;
74226   {
74227     try {
74228       result = (bool)(arg1)->Within(arg2);
74229     } catch (std::out_of_range& e) {
74230       {
74231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74232       };
74233     } catch (std::exception& e) {
74234       {
74235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74236       };
74237     } catch (Dali::DaliException e) {
74238       {
74239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74240       };
74241     } catch (...) {
74242       {
74243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74244       };
74245     }
74246   }
74247
74248   jresult = result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74254   void * jresult ;
74255   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74256   Dali::Toolkit::ItemRange *arg2 = 0 ;
74257   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74258
74259   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74260   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74261   if (!arg2) {
74262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74263     return 0;
74264   }
74265   {
74266     try {
74267       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74268     } catch (std::out_of_range& e) {
74269       {
74270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74271       };
74272     } catch (std::exception& e) {
74273       {
74274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (Dali::DaliException e) {
74277       {
74278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74279       };
74280     } catch (...) {
74281       {
74282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74283       };
74284     }
74285   }
74286
74287   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74288   return jresult;
74289 }
74290
74291
74292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74293   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74294   unsigned int arg2 ;
74295
74296   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74297   arg2 = (unsigned int)jarg2;
74298   if (arg1) (arg1)->begin = arg2;
74299 }
74300
74301
74302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74303   unsigned int jresult ;
74304   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74305   unsigned int result;
74306
74307   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74308   result = (unsigned int) ((arg1)->begin);
74309   jresult = result;
74310   return jresult;
74311 }
74312
74313
74314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74315   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74316   unsigned int arg2 ;
74317
74318   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74319   arg2 = (unsigned int)jarg2;
74320   if (arg1) (arg1)->end = arg2;
74321 }
74322
74323
74324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74325   unsigned int jresult ;
74326   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74327   unsigned int result;
74328
74329   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74330   result = (unsigned int) ((arg1)->end);
74331   jresult = result;
74332   return jresult;
74333 }
74334
74335
74336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74337   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74338
74339   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74340   {
74341     try {
74342       delete arg1;
74343     } catch (std::out_of_range& e) {
74344       {
74345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74346       };
74347     } catch (std::exception& e) {
74348       {
74349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74350       };
74351     } catch (Dali::DaliException e) {
74352       {
74353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74354       };
74355     } catch (...) {
74356       {
74357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74358       };
74359     }
74360   }
74361
74362 }
74363
74364
74365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74366   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74367
74368   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74369   {
74370     try {
74371       delete arg1;
74372     } catch (std::out_of_range& e) {
74373       {
74374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74375       };
74376     } catch (std::exception& e) {
74377       {
74378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74379       };
74380     } catch (Dali::DaliException e) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74387       };
74388     }
74389   }
74390
74391 }
74392
74393
74394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74395   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74396   Dali::Toolkit::ControlOrientation::Type arg2 ;
74397
74398   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74399   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74400   {
74401     try {
74402       (arg1)->SetOrientation(arg2);
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74418       };
74419     }
74420   }
74421
74422 }
74423
74424
74425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74426   int jresult ;
74427   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74428   Dali::Toolkit::ControlOrientation::Type result;
74429
74430   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74431   {
74432     try {
74433       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74434     } catch (std::out_of_range& e) {
74435       {
74436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74437       };
74438     } catch (std::exception& e) {
74439       {
74440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74441       };
74442     } catch (Dali::DaliException e) {
74443       {
74444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74445       };
74446     } catch (...) {
74447       {
74448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74449       };
74450     }
74451   }
74452
74453   jresult = (int)result;
74454   return jresult;
74455 }
74456
74457
74458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74459   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74460   Dali::Property::Map *arg2 = 0 ;
74461
74462   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74463   arg2 = (Dali::Property::Map *)jarg2;
74464   if (!arg2) {
74465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74466     return ;
74467   }
74468   {
74469     try {
74470       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74478       };
74479     } catch (Dali::DaliException e) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74482       };
74483     } catch (...) {
74484       {
74485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74486       };
74487     }
74488   }
74489
74490 }
74491
74492
74493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74494   void * jresult ;
74495   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74496   Dali::Property::Map result;
74497
74498   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74499   {
74500     try {
74501       result = (arg1)->GetLayoutProperties();
74502     } catch (std::out_of_range& e) {
74503       {
74504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74505       };
74506     } catch (std::exception& e) {
74507       {
74508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74509       };
74510     } catch (Dali::DaliException e) {
74511       {
74512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74513       };
74514     } catch (...) {
74515       {
74516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74517       };
74518     }
74519   }
74520
74521   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74522   return jresult;
74523 }
74524
74525
74526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74527   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74528   unsigned int arg2 ;
74529   Dali::Vector3 *arg3 = 0 ;
74530   Dali::Vector3 *arg4 = 0 ;
74531
74532   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74533   arg2 = (unsigned int)jarg2;
74534   arg3 = (Dali::Vector3 *)jarg3;
74535   if (!arg3) {
74536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74537     return ;
74538   }
74539   arg4 = (Dali::Vector3 *)jarg4;
74540   if (!arg4) {
74541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74542     return ;
74543   }
74544   {
74545     try {
74546       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74554       };
74555     } catch (Dali::DaliException e) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74558       };
74559     } catch (...) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74562       };
74563     }
74564   }
74565
74566 }
74567
74568
74569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74571   Dali::Vector3 *arg2 = 0 ;
74572
74573   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74574   arg2 = (Dali::Vector3 *)jarg2;
74575   if (!arg2) {
74576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74577     return ;
74578   }
74579   {
74580     try {
74581       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74582     } catch (std::out_of_range& e) {
74583       {
74584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74585       };
74586     } catch (std::exception& e) {
74587       {
74588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74589       };
74590     } catch (Dali::DaliException e) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74593       };
74594     } catch (...) {
74595       {
74596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74597       };
74598     }
74599   }
74600
74601 }
74602
74603
74604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74605   float jresult ;
74606   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74607   unsigned int arg2 ;
74608   Dali::Vector3 arg3 ;
74609   Dali::Vector3 *argp3 ;
74610   float result;
74611
74612   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74613   arg2 = (unsigned int)jarg2;
74614   argp3 = (Dali::Vector3 *)jarg3;
74615   if (!argp3) {
74616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74617     return 0;
74618   }
74619   arg3 = *argp3;
74620   {
74621     try {
74622       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74623     } catch (std::out_of_range& e) {
74624       {
74625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74626       };
74627     } catch (std::exception& e) {
74628       {
74629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74630       };
74631     } catch (Dali::DaliException e) {
74632       {
74633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74634       };
74635     } catch (...) {
74636       {
74637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74638       };
74639     }
74640   }
74641
74642   jresult = result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74648   float jresult ;
74649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74650   float arg2 ;
74651   float result;
74652
74653   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74654   arg2 = (float)jarg2;
74655   {
74656     try {
74657       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (Dali::DaliException e) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74673       };
74674     }
74675   }
74676
74677   jresult = result;
74678   return jresult;
74679 }
74680
74681
74682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74683   float jresult ;
74684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74685   unsigned int arg2 ;
74686   float result;
74687
74688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74689   arg2 = (unsigned int)jarg2;
74690   {
74691     try {
74692       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74693     } catch (std::out_of_range& e) {
74694       {
74695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74696       };
74697     } catch (std::exception& e) {
74698       {
74699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (Dali::DaliException e) {
74702       {
74703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74704       };
74705     } catch (...) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74708       };
74709     }
74710   }
74711
74712   jresult = result;
74713   return jresult;
74714 }
74715
74716
74717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74718   void * jresult ;
74719   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74720   float arg2 ;
74721   Dali::Vector3 arg3 ;
74722   Dali::Vector3 *argp3 ;
74723   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74724
74725   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74726   arg2 = (float)jarg2;
74727   argp3 = (Dali::Vector3 *)jarg3;
74728   if (!argp3) {
74729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74730     return 0;
74731   }
74732   arg3 = *argp3;
74733   {
74734     try {
74735       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74736     } catch (std::out_of_range& e) {
74737       {
74738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74739       };
74740     } catch (std::exception& e) {
74741       {
74742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (Dali::DaliException e) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74747       };
74748     } catch (...) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74751       };
74752     }
74753   }
74754
74755   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74756   return jresult;
74757 }
74758
74759
74760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74761   float jresult ;
74762   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74763   int arg2 ;
74764   float arg3 ;
74765   Dali::Vector3 *arg4 = 0 ;
74766   float result;
74767
74768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74769   arg2 = (int)jarg2;
74770   arg3 = (float)jarg3;
74771   arg4 = (Dali::Vector3 *)jarg4;
74772   if (!arg4) {
74773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74774     return 0;
74775   }
74776   {
74777     try {
74778       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74779     } catch (std::out_of_range& e) {
74780       {
74781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74782       };
74783     } catch (std::exception& e) {
74784       {
74785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74786       };
74787     } catch (Dali::DaliException e) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74790       };
74791     } catch (...) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74794       };
74795     }
74796   }
74797
74798   jresult = result;
74799   return jresult;
74800 }
74801
74802
74803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74804   unsigned int jresult ;
74805   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74806   Dali::Vector3 arg2 ;
74807   Dali::Vector3 *argp2 ;
74808   unsigned int result;
74809
74810   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74811   argp2 = (Dali::Vector3 *)jarg2;
74812   if (!argp2) {
74813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74814     return 0;
74815   }
74816   arg2 = *argp2;
74817   {
74818     try {
74819       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74827       };
74828     } catch (Dali::DaliException e) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74831       };
74832     } catch (...) {
74833       {
74834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74835       };
74836     }
74837   }
74838
74839   jresult = result;
74840   return jresult;
74841 }
74842
74843
74844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74845   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74846   unsigned int arg2 ;
74847   Dali::Vector3 *arg3 = 0 ;
74848   Dali::Vector3 *arg4 = 0 ;
74849
74850   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74851   arg2 = (unsigned int)jarg2;
74852   arg3 = (Dali::Vector3 *)jarg3;
74853   if (!arg3) {
74854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74855     return ;
74856   }
74857   arg4 = (Dali::Vector3 *)jarg4;
74858   if (!arg4) {
74859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74860     return ;
74861   }
74862   {
74863     try {
74864       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74865     } catch (std::out_of_range& e) {
74866       {
74867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74868       };
74869     } catch (std::exception& e) {
74870       {
74871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74872       };
74873     } catch (Dali::DaliException e) {
74874       {
74875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74876       };
74877     } catch (...) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74880       };
74881     }
74882   }
74883
74884 }
74885
74886
74887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74888   void * jresult ;
74889   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74890   Dali::Degree result;
74891
74892   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74893   {
74894     try {
74895       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74896     } catch (std::out_of_range& e) {
74897       {
74898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74899       };
74900     } catch (std::exception& e) {
74901       {
74902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74903       };
74904     } catch (Dali::DaliException e) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74907       };
74908     } catch (...) {
74909       {
74910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74911       };
74912     }
74913   }
74914
74915   jresult = new Dali::Degree((const Dali::Degree &)result);
74916   return jresult;
74917 }
74918
74919
74920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74921   float jresult ;
74922   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74923   float result;
74924
74925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74926   {
74927     try {
74928       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74936       };
74937     } catch (Dali::DaliException e) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74940       };
74941     } catch (...) {
74942       {
74943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74944       };
74945     }
74946   }
74947
74948   jresult = result;
74949   return jresult;
74950 }
74951
74952
74953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74954   float jresult ;
74955   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74956   float result;
74957
74958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74959   {
74960     try {
74961       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74962     } catch (std::out_of_range& e) {
74963       {
74964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74965       };
74966     } catch (std::exception& e) {
74967       {
74968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74969       };
74970     } catch (Dali::DaliException e) {
74971       {
74972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74973       };
74974     } catch (...) {
74975       {
74976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74977       };
74978     }
74979   }
74980
74981   jresult = result;
74982   return jresult;
74983 }
74984
74985
74986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74987   float jresult ;
74988   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74989   float result;
74990
74991   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74992   {
74993     try {
74994       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74995     } catch (std::out_of_range& e) {
74996       {
74997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74998       };
74999     } catch (std::exception& e) {
75000       {
75001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75002       };
75003     } catch (Dali::DaliException e) {
75004       {
75005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75006       };
75007     } catch (...) {
75008       {
75009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75010       };
75011     }
75012   }
75013
75014   jresult = result;
75015   return jresult;
75016 }
75017
75018
75019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75020   int jresult ;
75021   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75022   int arg2 ;
75023   int arg3 ;
75024   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75025   bool arg5 ;
75026   int result;
75027
75028   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75029   arg2 = (int)jarg2;
75030   arg3 = (int)jarg3;
75031   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75032   arg5 = jarg5 ? true : false;
75033   {
75034     try {
75035       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = result;
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75061   float jresult ;
75062   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75063   float result;
75064
75065   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75066   {
75067     try {
75068       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75069     } catch (std::out_of_range& e) {
75070       {
75071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75072       };
75073     } catch (std::exception& e) {
75074       {
75075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75076       };
75077     } catch (Dali::DaliException e) {
75078       {
75079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75084       };
75085     }
75086   }
75087
75088   jresult = result;
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75094   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75095   Dali::Actor *arg2 = 0 ;
75096   int arg3 ;
75097   Dali::Vector3 *arg4 = 0 ;
75098   Dali::Actor *arg5 = 0 ;
75099
75100   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75101   arg2 = (Dali::Actor *)jarg2;
75102   if (!arg2) {
75103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75104     return ;
75105   }
75106   arg3 = (int)jarg3;
75107   arg4 = (Dali::Vector3 *)jarg4;
75108   if (!arg4) {
75109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75110     return ;
75111   }
75112   arg5 = (Dali::Actor *)jarg5;
75113   if (!arg5) {
75114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75115     return ;
75116   }
75117   {
75118     try {
75119       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75120     } catch (std::out_of_range& e) {
75121       {
75122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75123       };
75124     } catch (std::exception& e) {
75125       {
75126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75127       };
75128     } catch (Dali::DaliException e) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75131       };
75132     } catch (...) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75135       };
75136     }
75137   }
75138
75139 }
75140
75141
75142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75143   void * jresult ;
75144   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75145   int arg2 ;
75146   float arg3 ;
75147   Dali::Vector3 *arg4 = 0 ;
75148   Dali::Vector3 result;
75149
75150   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75151   arg2 = (int)jarg2;
75152   arg3 = (float)jarg3;
75153   arg4 = (Dali::Vector3 *)jarg4;
75154   if (!arg4) {
75155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75156     return 0;
75157   }
75158   {
75159     try {
75160       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75161     } catch (std::out_of_range& e) {
75162       {
75163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (std::exception& e) {
75166       {
75167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75168       };
75169     } catch (Dali::DaliException e) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75172       };
75173     } catch (...) {
75174       {
75175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75176       };
75177     }
75178   }
75179
75180   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75181   return jresult;
75182 }
75183
75184
75185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75186   void * jresult ;
75187   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75188   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75189
75190   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75191   {
75192     try {
75193       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75194     } catch (std::out_of_range& e) {
75195       {
75196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (std::exception& e) {
75199       {
75200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75201       };
75202     } catch (Dali::DaliException e) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75205       };
75206     } catch (...) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75209       };
75210     }
75211   }
75212
75213   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75214   return jresult;
75215 }
75216
75217
75218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75219   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75220
75221   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75222   {
75223     try {
75224       delete arg1;
75225     } catch (std::out_of_range& e) {
75226       {
75227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75228       };
75229     } catch (std::exception& e) {
75230       {
75231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75232       };
75233     } catch (Dali::DaliException e) {
75234       {
75235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75236       };
75237     } catch (...) {
75238       {
75239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75240       };
75241     }
75242   }
75243
75244 }
75245
75246
75247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75248   unsigned int jresult ;
75249   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75250   unsigned int result;
75251
75252   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75253   {
75254     try {
75255       result = (unsigned int)(arg1)->GetNumberOfItems();
75256     } catch (std::out_of_range& e) {
75257       {
75258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75259       };
75260     } catch (std::exception& e) {
75261       {
75262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75263       };
75264     } catch (Dali::DaliException e) {
75265       {
75266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75267       };
75268     } catch (...) {
75269       {
75270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75271       };
75272     }
75273   }
75274
75275   jresult = result;
75276   return jresult;
75277 }
75278
75279
75280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75281   void * jresult ;
75282   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75283   unsigned int arg2 ;
75284   Dali::Actor result;
75285
75286   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75287   arg2 = (unsigned int)jarg2;
75288   {
75289     try {
75290       result = (arg1)->NewItem(arg2);
75291     } catch (std::out_of_range& e) {
75292       {
75293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (std::exception& e) {
75296       {
75297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75298       };
75299     } catch (Dali::DaliException e) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75302       };
75303     } catch (...) {
75304       {
75305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75306       };
75307     }
75308   }
75309
75310   jresult = new Dali::Actor((const Dali::Actor &)result);
75311   return jresult;
75312 }
75313
75314
75315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75316   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75317   unsigned int arg2 ;
75318   Dali::Actor arg3 ;
75319   Dali::Actor *argp3 ;
75320
75321   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75322   arg2 = (unsigned int)jarg2;
75323   argp3 = (Dali::Actor *)jarg3;
75324   if (!argp3) {
75325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75326     return ;
75327   }
75328   arg3 = *argp3;
75329   {
75330     try {
75331       (arg1)->ItemReleased(arg2,arg3);
75332     } catch (std::out_of_range& e) {
75333       {
75334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75335       };
75336     } catch (std::exception& e) {
75337       {
75338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75339       };
75340     } catch (Dali::DaliException e) {
75341       {
75342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75343       };
75344     } catch (...) {
75345       {
75346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75347       };
75348     }
75349   }
75350
75351 }
75352
75353
75354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75355   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75356   unsigned int arg2 ;
75357   Dali::Actor arg3 ;
75358   Dali::Actor *argp3 ;
75359
75360   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75361   arg2 = (unsigned int)jarg2;
75362   argp3 = (Dali::Actor *)jarg3;
75363   if (!argp3) {
75364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75365     return ;
75366   }
75367   arg3 = *argp3;
75368   {
75369     try {
75370       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75371     } catch (std::out_of_range& e) {
75372       {
75373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75374       };
75375     } catch (std::exception& e) {
75376       {
75377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75378       };
75379     } catch (Dali::DaliException e) {
75380       {
75381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75382       };
75383     } catch (...) {
75384       {
75385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75386       };
75387     }
75388   }
75389
75390 }
75391
75392
75393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75394   void * jresult ;
75395   Dali::Toolkit::ItemFactory *result = 0 ;
75396
75397   {
75398     try {
75399       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75400     } catch (std::out_of_range& e) {
75401       {
75402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75403       };
75404     } catch (std::exception& e) {
75405       {
75406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75407       };
75408     } catch (Dali::DaliException e) {
75409       {
75410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75411       };
75412     } catch (...) {
75413       {
75414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75415       };
75416     }
75417   }
75418
75419   jresult = (void *)result;
75420   return jresult;
75421 }
75422
75423
75424 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) {
75425   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75426   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75427   if (director) {
75428     director->swig_connect_director(callback0, callback1, callback2);
75429   }
75430 }
75431
75432
75433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75434   int jresult ;
75435   int result;
75436
75437   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75438   jresult = (int)result;
75439   return jresult;
75440 }
75441
75442
75443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75444   int jresult ;
75445   int result;
75446
75447   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75448   jresult = (int)result;
75449   return jresult;
75450 }
75451
75452
75453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75454   int jresult ;
75455   int result;
75456
75457   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75458   jresult = (int)result;
75459   return jresult;
75460 }
75461
75462
75463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75464   int jresult ;
75465   int result;
75466
75467   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75468   jresult = (int)result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75474   int jresult ;
75475   int result;
75476
75477   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75478   jresult = (int)result;
75479   return jresult;
75480 }
75481
75482
75483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75484   int jresult ;
75485   int result;
75486
75487   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75488   jresult = (int)result;
75489   return jresult;
75490 }
75491
75492
75493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75494   int jresult ;
75495   int result;
75496
75497   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75498   jresult = (int)result;
75499   return jresult;
75500 }
75501
75502
75503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75504   int jresult ;
75505   int result;
75506
75507   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75508   jresult = (int)result;
75509   return jresult;
75510 }
75511
75512
75513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75514   int jresult ;
75515   int result;
75516
75517   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75518   jresult = (int)result;
75519   return jresult;
75520 }
75521
75522
75523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75524   int jresult ;
75525   int result;
75526
75527   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75528   jresult = (int)result;
75529   return jresult;
75530 }
75531
75532
75533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75534   int jresult ;
75535   int result;
75536
75537   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75538   jresult = (int)result;
75539   return jresult;
75540 }
75541
75542
75543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75544   void * jresult ;
75545   Dali::Toolkit::ItemView::Property *result = 0 ;
75546
75547   {
75548     try {
75549       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75550     } catch (std::out_of_range& e) {
75551       {
75552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75553       };
75554     } catch (std::exception& e) {
75555       {
75556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75557       };
75558     } catch (Dali::DaliException e) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75561       };
75562     } catch (...) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75565       };
75566     }
75567   }
75568
75569   jresult = (void *)result;
75570   return jresult;
75571 }
75572
75573
75574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75575   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75576
75577   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75578   {
75579     try {
75580       delete arg1;
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75588       };
75589     } catch (Dali::DaliException e) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75592       };
75593     } catch (...) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75596       };
75597     }
75598   }
75599
75600 }
75601
75602
75603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75604   void * jresult ;
75605   Dali::Toolkit::ItemView *result = 0 ;
75606
75607   {
75608     try {
75609       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75610     } catch (std::out_of_range& e) {
75611       {
75612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75613       };
75614     } catch (std::exception& e) {
75615       {
75616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75617       };
75618     } catch (Dali::DaliException e) {
75619       {
75620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75621       };
75622     } catch (...) {
75623       {
75624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75625       };
75626     }
75627   }
75628
75629   jresult = (void *)result;
75630   return jresult;
75631 }
75632
75633
75634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75635   void * jresult ;
75636   Dali::Toolkit::ItemView *arg1 = 0 ;
75637   Dali::Toolkit::ItemView *result = 0 ;
75638
75639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75640   if (!arg1) {
75641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75642     return 0;
75643   }
75644   {
75645     try {
75646       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75647     } catch (std::out_of_range& e) {
75648       {
75649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75650       };
75651     } catch (std::exception& e) {
75652       {
75653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75654       };
75655     } catch (Dali::DaliException e) {
75656       {
75657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75658       };
75659     } catch (...) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75662       };
75663     }
75664   }
75665
75666   jresult = (void *)result;
75667   return jresult;
75668 }
75669
75670
75671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75672   void * jresult ;
75673   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75674   Dali::Toolkit::ItemView *arg2 = 0 ;
75675   Dali::Toolkit::ItemView *result = 0 ;
75676
75677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75678   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75679   if (!arg2) {
75680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75681     return 0;
75682   }
75683   {
75684     try {
75685       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75686     } catch (std::out_of_range& e) {
75687       {
75688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75689       };
75690     } catch (std::exception& e) {
75691       {
75692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75693       };
75694     } catch (Dali::DaliException e) {
75695       {
75696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75697       };
75698     } catch (...) {
75699       {
75700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75701       };
75702     }
75703   }
75704
75705   jresult = (void *)result;
75706   return jresult;
75707 }
75708
75709
75710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75711   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75712
75713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75714   {
75715     try {
75716       delete arg1;
75717     } catch (std::out_of_range& e) {
75718       {
75719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75720       };
75721     } catch (std::exception& e) {
75722       {
75723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75724       };
75725     } catch (Dali::DaliException e) {
75726       {
75727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75732       };
75733     }
75734   }
75735
75736 }
75737
75738
75739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75740   void * jresult ;
75741   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75742   Dali::Toolkit::ItemView result;
75743
75744   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75745   if (!arg1) {
75746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75747     return 0;
75748   }
75749   {
75750     try {
75751       result = Dali::Toolkit::ItemView::New(*arg1);
75752     } catch (std::out_of_range& e) {
75753       {
75754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75755       };
75756     } catch (std::exception& e) {
75757       {
75758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75759       };
75760     } catch (Dali::DaliException e) {
75761       {
75762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75763       };
75764     } catch (...) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75767       };
75768     }
75769   }
75770
75771   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75772   return jresult;
75773 }
75774
75775
75776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75777   void * jresult ;
75778   Dali::BaseHandle arg1 ;
75779   Dali::BaseHandle *argp1 ;
75780   Dali::Toolkit::ItemView result;
75781
75782   argp1 = (Dali::BaseHandle *)jarg1;
75783   if (!argp1) {
75784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75785     return 0;
75786   }
75787   arg1 = *argp1;
75788   {
75789     try {
75790       result = Dali::Toolkit::ItemView::DownCast(arg1);
75791     } catch (std::out_of_range& e) {
75792       {
75793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (std::exception& e) {
75796       {
75797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75798       };
75799     } catch (Dali::DaliException e) {
75800       {
75801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75802       };
75803     } catch (...) {
75804       {
75805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75806       };
75807     }
75808   }
75809
75810   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75811   return jresult;
75812 }
75813
75814
75815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75816   unsigned int jresult ;
75817   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75818   unsigned int result;
75819
75820   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75821   {
75822     try {
75823       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75831       };
75832     } catch (Dali::DaliException e) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75835       };
75836     } catch (...) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75839       };
75840     }
75841   }
75842
75843   jresult = result;
75844   return jresult;
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75850   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75851
75852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75853   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75854   if (!arg2) {
75855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75856     return ;
75857   }
75858   {
75859     try {
75860       (arg1)->AddLayout(*arg2);
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (Dali::DaliException e) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75876       };
75877     }
75878   }
75879
75880 }
75881
75882
75883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75884   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75885   unsigned int arg2 ;
75886
75887   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75888   arg2 = (unsigned int)jarg2;
75889   {
75890     try {
75891       (arg1)->RemoveLayout(arg2);
75892     } catch (std::out_of_range& e) {
75893       {
75894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75895       };
75896     } catch (std::exception& e) {
75897       {
75898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75899       };
75900     } catch (Dali::DaliException e) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75903       };
75904     } catch (...) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75907       };
75908     }
75909   }
75910
75911 }
75912
75913
75914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75915   void * jresult ;
75916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75917   unsigned int arg2 ;
75918   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75919
75920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75921   arg2 = (unsigned int)jarg2;
75922   {
75923     try {
75924       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75925     } catch (std::out_of_range& e) {
75926       {
75927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75928       };
75929     } catch (std::exception& e) {
75930       {
75931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75932       };
75933     } catch (Dali::DaliException e) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75936       };
75937     } catch (...) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75940       };
75941     }
75942   }
75943
75944   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75945   return jresult;
75946 }
75947
75948
75949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75950   void * jresult ;
75951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75952   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75953
75954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75955   {
75956     try {
75957       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75958     } catch (std::out_of_range& e) {
75959       {
75960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75961       };
75962     } catch (std::exception& e) {
75963       {
75964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75965       };
75966     } catch (Dali::DaliException e) {
75967       {
75968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75969       };
75970     } catch (...) {
75971       {
75972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75973       };
75974     }
75975   }
75976
75977   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75978   return jresult;
75979 }
75980
75981
75982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75983   float jresult ;
75984   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75985   Dali::Toolkit::ItemId arg2 ;
75986   float result;
75987
75988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75989   arg2 = (Dali::Toolkit::ItemId)jarg2;
75990   {
75991     try {
75992       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76000       };
76001     } catch (Dali::DaliException e) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76004       };
76005     } catch (...) {
76006       {
76007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76008       };
76009     }
76010   }
76011
76012   jresult = result;
76013   return jresult;
76014 }
76015
76016
76017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76018   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76019   unsigned int arg2 ;
76020   Dali::Vector3 arg3 ;
76021   float arg4 ;
76022   Dali::Vector3 *argp3 ;
76023
76024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76025   arg2 = (unsigned int)jarg2;
76026   argp3 = (Dali::Vector3 *)jarg3;
76027   if (!argp3) {
76028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76029     return ;
76030   }
76031   arg3 = *argp3;
76032   arg4 = (float)jarg4;
76033   {
76034     try {
76035       (arg1)->ActivateLayout(arg2,arg3,arg4);
76036     } catch (std::out_of_range& e) {
76037       {
76038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76039       };
76040     } catch (std::exception& e) {
76041       {
76042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76043       };
76044     } catch (Dali::DaliException e) {
76045       {
76046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76047       };
76048     } catch (...) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76051       };
76052     }
76053   }
76054
76055 }
76056
76057
76058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76060
76061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76062   {
76063     try {
76064       (arg1)->DeactivateCurrentLayout();
76065     } catch (std::out_of_range& e) {
76066       {
76067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76068       };
76069     } catch (std::exception& e) {
76070       {
76071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76072       };
76073     } catch (Dali::DaliException e) {
76074       {
76075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76076       };
76077     } catch (...) {
76078       {
76079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76080       };
76081     }
76082   }
76083
76084 }
76085
76086
76087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76089   float arg2 ;
76090
76091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76092   arg2 = (float)jarg2;
76093   {
76094     try {
76095       (arg1)->SetMinimumSwipeSpeed(arg2);
76096     } catch (std::out_of_range& e) {
76097       {
76098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (std::exception& e) {
76101       {
76102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (Dali::DaliException e) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76107       };
76108     } catch (...) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76111       };
76112     }
76113   }
76114
76115 }
76116
76117
76118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76119   float jresult ;
76120   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76121   float result;
76122
76123   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76124   {
76125     try {
76126       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76127     } catch (std::out_of_range& e) {
76128       {
76129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76130       };
76131     } catch (std::exception& e) {
76132       {
76133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (Dali::DaliException e) {
76136       {
76137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76138       };
76139     } catch (...) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76142       };
76143     }
76144   }
76145
76146   jresult = result;
76147   return jresult;
76148 }
76149
76150
76151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76152   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76153   float arg2 ;
76154
76155   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76156   arg2 = (float)jarg2;
76157   {
76158     try {
76159       (arg1)->SetMinimumSwipeDistance(arg2);
76160     } catch (std::out_of_range& e) {
76161       {
76162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (std::exception& e) {
76165       {
76166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76167       };
76168     } catch (Dali::DaliException e) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76171       };
76172     } catch (...) {
76173       {
76174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76175       };
76176     }
76177   }
76178
76179 }
76180
76181
76182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76183   float jresult ;
76184   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76185   float result;
76186
76187   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76188   {
76189     try {
76190       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76191     } catch (std::out_of_range& e) {
76192       {
76193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76194       };
76195     } catch (std::exception& e) {
76196       {
76197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76198       };
76199     } catch (Dali::DaliException e) {
76200       {
76201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76202       };
76203     } catch (...) {
76204       {
76205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76206       };
76207     }
76208   }
76209
76210   jresult = result;
76211   return jresult;
76212 }
76213
76214
76215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76216   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76217   float arg2 ;
76218
76219   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76220   arg2 = (float)jarg2;
76221   {
76222     try {
76223       (arg1)->SetWheelScrollDistanceStep(arg2);
76224     } catch (std::out_of_range& e) {
76225       {
76226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76227       };
76228     } catch (std::exception& e) {
76229       {
76230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76231       };
76232     } catch (Dali::DaliException e) {
76233       {
76234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76235       };
76236     } catch (...) {
76237       {
76238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76239       };
76240     }
76241   }
76242
76243 }
76244
76245
76246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76247   float jresult ;
76248   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76249   float result;
76250
76251   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76252   {
76253     try {
76254       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76255     } catch (std::out_of_range& e) {
76256       {
76257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76258       };
76259     } catch (std::exception& e) {
76260       {
76261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76262       };
76263     } catch (Dali::DaliException e) {
76264       {
76265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76266       };
76267     } catch (...) {
76268       {
76269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76270       };
76271     }
76272   }
76273
76274   jresult = result;
76275   return jresult;
76276 }
76277
76278
76279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76280   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76281   bool arg2 ;
76282
76283   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76284   arg2 = jarg2 ? true : false;
76285   {
76286     try {
76287       (arg1)->SetAnchoring(arg2);
76288     } catch (std::out_of_range& e) {
76289       {
76290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76291       };
76292     } catch (std::exception& e) {
76293       {
76294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (Dali::DaliException e) {
76297       {
76298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76299       };
76300     } catch (...) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76303       };
76304     }
76305   }
76306
76307 }
76308
76309 //// ========================= end of part 3 =============================
76310
76311 //// ========================== start part 4 ===============================
76312
76313
76314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76315   unsigned int jresult ;
76316   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76317   bool result;
76318
76319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76320   {
76321     try {
76322       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
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 = result;
76343   return jresult;
76344 }
76345
76346
76347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76348   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76349   float arg2 ;
76350
76351   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76352   arg2 = (float)jarg2;
76353   {
76354     try {
76355       (arg1)->SetAnchoringDuration(arg2);
76356     } catch (std::out_of_range& e) {
76357       {
76358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (std::exception& e) {
76361       {
76362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76363       };
76364     } catch (Dali::DaliException e) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76367       };
76368     } catch (...) {
76369       {
76370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76371       };
76372     }
76373   }
76374
76375 }
76376
76377
76378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76379   float jresult ;
76380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76381   float result;
76382
76383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76384   {
76385     try {
76386       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76387     } catch (std::out_of_range& e) {
76388       {
76389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (std::exception& e) {
76392       {
76393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76394       };
76395     } catch (Dali::DaliException e) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76398       };
76399     } catch (...) {
76400       {
76401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76402       };
76403     }
76404   }
76405
76406   jresult = result;
76407   return jresult;
76408 }
76409
76410
76411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76413   Dali::Toolkit::ItemId arg2 ;
76414   float arg3 ;
76415
76416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76417   arg2 = (Dali::Toolkit::ItemId)jarg2;
76418   arg3 = (float)jarg3;
76419   {
76420     try {
76421       (arg1)->ScrollToItem(arg2,arg3);
76422     } catch (std::out_of_range& e) {
76423       {
76424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76425       };
76426     } catch (std::exception& e) {
76427       {
76428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76429       };
76430     } catch (Dali::DaliException e) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76433       };
76434     } catch (...) {
76435       {
76436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76437       };
76438     }
76439   }
76440
76441 }
76442
76443
76444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76445   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76446   float arg2 ;
76447
76448   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76449   arg2 = (float)jarg2;
76450   {
76451     try {
76452       (arg1)->SetRefreshInterval(arg2);
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76468       };
76469     }
76470   }
76471
76472 }
76473
76474
76475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76476   float jresult ;
76477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76478   float result;
76479
76480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76481   {
76482     try {
76483       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76484     } catch (std::out_of_range& e) {
76485       {
76486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76487       };
76488     } catch (std::exception& e) {
76489       {
76490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76491       };
76492     } catch (Dali::DaliException e) {
76493       {
76494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76495       };
76496     } catch (...) {
76497       {
76498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76499       };
76500     }
76501   }
76502
76503   jresult = result;
76504   return jresult;
76505 }
76506
76507
76508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76510
76511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76512   {
76513     try {
76514       (arg1)->Refresh();
76515     } catch (std::out_of_range& e) {
76516       {
76517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (std::exception& e) {
76520       {
76521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76522       };
76523     } catch (Dali::DaliException e) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76526       };
76527     } catch (...) {
76528       {
76529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76530       };
76531     }
76532   }
76533
76534 }
76535
76536
76537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76538   void * jresult ;
76539   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76540   Dali::Toolkit::ItemId arg2 ;
76541   Dali::Actor result;
76542
76543   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76544   arg2 = (Dali::Toolkit::ItemId)jarg2;
76545   {
76546     try {
76547       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76548     } catch (std::out_of_range& e) {
76549       {
76550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76551       };
76552     } catch (std::exception& e) {
76553       {
76554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76555       };
76556     } catch (Dali::DaliException e) {
76557       {
76558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76559       };
76560     } catch (...) {
76561       {
76562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76563       };
76564     }
76565   }
76566
76567   jresult = new Dali::Actor((const Dali::Actor &)result);
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76573   unsigned int jresult ;
76574   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76575   Dali::Actor arg2 ;
76576   Dali::Actor *argp2 ;
76577   Dali::Toolkit::ItemId result;
76578
76579   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76580   argp2 = (Dali::Actor *)jarg2;
76581   if (!argp2) {
76582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76583     return 0;
76584   }
76585   arg2 = *argp2;
76586   {
76587     try {
76588       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76589     } catch (std::out_of_range& e) {
76590       {
76591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76592       };
76593     } catch (std::exception& e) {
76594       {
76595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76596       };
76597     } catch (Dali::DaliException e) {
76598       {
76599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76600       };
76601     } catch (...) {
76602       {
76603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76604       };
76605     }
76606   }
76607
76608   jresult = result;
76609   return jresult;
76610 }
76611
76612
76613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76615   Dali::Toolkit::Item arg2 ;
76616   float arg3 ;
76617   Dali::Toolkit::Item *argp2 ;
76618
76619   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76620   argp2 = (Dali::Toolkit::Item *)jarg2;
76621   if (!argp2) {
76622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76623     return ;
76624   }
76625   arg2 = *argp2;
76626   arg3 = (float)jarg3;
76627   {
76628     try {
76629       (arg1)->InsertItem(arg2,arg3);
76630     } catch (std::out_of_range& e) {
76631       {
76632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76633       };
76634     } catch (std::exception& e) {
76635       {
76636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76637       };
76638     } catch (Dali::DaliException e) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76641       };
76642     } catch (...) {
76643       {
76644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76645       };
76646     }
76647   }
76648
76649 }
76650
76651
76652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76653   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76654   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76655   float arg3 ;
76656
76657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76658   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76659   if (!arg2) {
76660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76661     return ;
76662   }
76663   arg3 = (float)jarg3;
76664   {
76665     try {
76666       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76667     } catch (std::out_of_range& e) {
76668       {
76669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76670       };
76671     } catch (std::exception& e) {
76672       {
76673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76674       };
76675     } catch (Dali::DaliException e) {
76676       {
76677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76678       };
76679     } catch (...) {
76680       {
76681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76682       };
76683     }
76684   }
76685
76686 }
76687
76688
76689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76691   Dali::Toolkit::ItemId arg2 ;
76692   float arg3 ;
76693
76694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76695   arg2 = (Dali::Toolkit::ItemId)jarg2;
76696   arg3 = (float)jarg3;
76697   {
76698     try {
76699       (arg1)->RemoveItem(arg2,arg3);
76700     } catch (std::out_of_range& e) {
76701       {
76702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76703       };
76704     } catch (std::exception& e) {
76705       {
76706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76707       };
76708     } catch (Dali::DaliException e) {
76709       {
76710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76711       };
76712     } catch (...) {
76713       {
76714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76715       };
76716     }
76717   }
76718
76719 }
76720
76721
76722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76724   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76725   float arg3 ;
76726
76727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76728   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76729   if (!arg2) {
76730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76731     return ;
76732   }
76733   arg3 = (float)jarg3;
76734   {
76735     try {
76736       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76737     } catch (std::out_of_range& e) {
76738       {
76739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76740       };
76741     } catch (std::exception& e) {
76742       {
76743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (Dali::DaliException e) {
76746       {
76747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76748       };
76749     } catch (...) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76752       };
76753     }
76754   }
76755
76756 }
76757
76758
76759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76761   Dali::Toolkit::Item arg2 ;
76762   float arg3 ;
76763   Dali::Toolkit::Item *argp2 ;
76764
76765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76766   argp2 = (Dali::Toolkit::Item *)jarg2;
76767   if (!argp2) {
76768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76769     return ;
76770   }
76771   arg2 = *argp2;
76772   arg3 = (float)jarg3;
76773   {
76774     try {
76775       (arg1)->ReplaceItem(arg2,arg3);
76776     } catch (std::out_of_range& e) {
76777       {
76778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76779       };
76780     } catch (std::exception& e) {
76781       {
76782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76783       };
76784     } catch (Dali::DaliException e) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76787       };
76788     } catch (...) {
76789       {
76790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76791       };
76792     }
76793   }
76794
76795 }
76796
76797
76798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76799   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76800   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76801   float arg3 ;
76802
76803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76804   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76805   if (!arg2) {
76806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76807     return ;
76808   }
76809   arg3 = (float)jarg3;
76810   {
76811     try {
76812       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76813     } catch (std::out_of_range& e) {
76814       {
76815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76816       };
76817     } catch (std::exception& e) {
76818       {
76819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76820       };
76821     } catch (Dali::DaliException e) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76824       };
76825     } catch (...) {
76826       {
76827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76828       };
76829     }
76830   }
76831
76832 }
76833
76834
76835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76836   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76837   Dali::Vector3 *arg2 = 0 ;
76838
76839   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76840   arg2 = (Dali::Vector3 *)jarg2;
76841   if (!arg2) {
76842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76843     return ;
76844   }
76845   {
76846     try {
76847       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76848     } catch (std::out_of_range& e) {
76849       {
76850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76851       };
76852     } catch (std::exception& e) {
76853       {
76854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (Dali::DaliException e) {
76857       {
76858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76859       };
76860     } catch (...) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76863       };
76864     }
76865   }
76866
76867 }
76868
76869
76870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76871   void * jresult ;
76872   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76873   Dali::Vector3 result;
76874
76875   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76876   {
76877     try {
76878       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76879     } catch (std::out_of_range& e) {
76880       {
76881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (std::exception& e) {
76884       {
76885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (Dali::DaliException e) {
76888       {
76889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76890       };
76891     } catch (...) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76894       };
76895     }
76896   }
76897
76898   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76899   return jresult;
76900 }
76901
76902
76903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76904   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76905   Dali::Vector3 *arg2 = 0 ;
76906
76907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76908   arg2 = (Dali::Vector3 *)jarg2;
76909   if (!arg2) {
76910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76911     return ;
76912   }
76913   {
76914     try {
76915       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76931       };
76932     }
76933   }
76934
76935 }
76936
76937
76938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76939   void * jresult ;
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   Dali::Vector3 result;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   {
76945     try {
76946       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76947     } catch (std::out_of_range& e) {
76948       {
76949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (std::exception& e) {
76952       {
76953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (Dali::DaliException e) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76958       };
76959     } catch (...) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76962       };
76963     }
76964   }
76965
76966   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76973   Dali::Toolkit::ItemRange *arg2 = 0 ;
76974
76975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76976   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76977   if (!arg2) {
76978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76979     return ;
76980   }
76981   {
76982     try {
76983       (arg1)->GetItemsRange(*arg2);
76984     } catch (std::out_of_range& e) {
76985       {
76986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76987       };
76988     } catch (std::exception& e) {
76989       {
76990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76991       };
76992     } catch (Dali::DaliException e) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76995       };
76996     } catch (...) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76999       };
77000     }
77001   }
77002
77003 }
77004
77005
77006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77007   void * jresult ;
77008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77009   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77010
77011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77012   {
77013     try {
77014       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77015     } catch (std::out_of_range& e) {
77016       {
77017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77018       };
77019     } catch (std::exception& e) {
77020       {
77021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77022       };
77023     } catch (Dali::DaliException e) {
77024       {
77025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77026       };
77027     } catch (...) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77030       };
77031     }
77032   }
77033
77034   jresult = (void *)result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77040   Dali::Vector3 *arg1 = 0 ;
77041   PropertyInputContainer *arg2 = 0 ;
77042
77043   arg1 = (Dali::Vector3 *)jarg1;
77044   if (!arg1) {
77045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77046     return ;
77047   }
77048   arg2 = (PropertyInputContainer *)jarg2;
77049   if (!arg2) {
77050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77051     return ;
77052   }
77053   {
77054     try {
77055       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77056     } catch (std::out_of_range& e) {
77057       {
77058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77059       };
77060     } catch (std::exception& e) {
77061       {
77062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77063       };
77064     } catch (Dali::DaliException e) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77067       };
77068     } catch (...) {
77069       {
77070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77071       };
77072     }
77073   }
77074
77075 }
77076
77077
77078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77079   Dali::Vector3 *arg1 = 0 ;
77080   PropertyInputContainer *arg2 = 0 ;
77081
77082   arg1 = (Dali::Vector3 *)jarg1;
77083   if (!arg1) {
77084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77085     return ;
77086   }
77087   arg2 = (PropertyInputContainer *)jarg2;
77088   if (!arg2) {
77089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77090     return ;
77091   }
77092   {
77093     try {
77094       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77095     } catch (std::out_of_range& e) {
77096       {
77097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77098       };
77099     } catch (std::exception& e) {
77100       {
77101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77102       };
77103     } catch (Dali::DaliException e) {
77104       {
77105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77106       };
77107     } catch (...) {
77108       {
77109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77110       };
77111     }
77112   }
77113
77114 }
77115
77116
77117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77118   void * jresult ;
77119   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77120
77121   {
77122     try {
77123       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77124     } catch (std::out_of_range& e) {
77125       {
77126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77127       };
77128     } catch (std::exception& e) {
77129       {
77130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77131       };
77132     } catch (Dali::DaliException e) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77135       };
77136     } catch (...) {
77137       {
77138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77139       };
77140     }
77141   }
77142
77143   jresult = (void *)result;
77144   return jresult;
77145 }
77146
77147
77148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77149   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77150
77151   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77152   {
77153     try {
77154       delete arg1;
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77162       };
77163     } catch (Dali::DaliException e) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77166       };
77167     } catch (...) {
77168       {
77169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77170       };
77171     }
77172   }
77173
77174 }
77175
77176
77177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77178   void * jresult ;
77179   Dali::Path arg1 ;
77180   Dali::Vector3 *arg2 = 0 ;
77181   Dali::Property::Index arg3 ;
77182   Dali::Vector3 *arg4 = 0 ;
77183   unsigned int arg5 ;
77184   Dali::Path *argp1 ;
77185   Dali::Toolkit::ScrollViewPagePathEffect result;
77186
77187   argp1 = (Dali::Path *)jarg1;
77188   if (!argp1) {
77189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77190     return 0;
77191   }
77192   arg1 = *argp1;
77193   arg2 = (Dali::Vector3 *)jarg2;
77194   if (!arg2) {
77195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77196     return 0;
77197   }
77198   arg3 = (Dali::Property::Index)jarg3;
77199   arg4 = (Dali::Vector3 *)jarg4;
77200   if (!arg4) {
77201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77202     return 0;
77203   }
77204   arg5 = (unsigned int)jarg5;
77205   {
77206     try {
77207       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77208     } catch (std::out_of_range& e) {
77209       {
77210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77211       };
77212     } catch (std::exception& e) {
77213       {
77214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77215       };
77216     } catch (Dali::DaliException e) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77219       };
77220     } catch (...) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77223       };
77224     }
77225   }
77226
77227   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77228   return jresult;
77229 }
77230
77231
77232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77233   void * jresult ;
77234   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77235
77236   {
77237     try {
77238       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77239     } catch (std::out_of_range& e) {
77240       {
77241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (std::exception& e) {
77244       {
77245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77246       };
77247     } catch (Dali::DaliException e) {
77248       {
77249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77250       };
77251     } catch (...) {
77252       {
77253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77254       };
77255     }
77256   }
77257
77258   jresult = (void *)result;
77259   return jresult;
77260 }
77261
77262
77263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77264   void * jresult ;
77265   Dali::BaseHandle arg1 ;
77266   Dali::BaseHandle *argp1 ;
77267   Dali::Toolkit::ScrollViewPagePathEffect result;
77268
77269   argp1 = (Dali::BaseHandle *)jarg1;
77270   if (!argp1) {
77271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77272     return 0;
77273   }
77274   arg1 = *argp1;
77275   {
77276     try {
77277       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77278     } catch (std::out_of_range& e) {
77279       {
77280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77281       };
77282     } catch (std::exception& e) {
77283       {
77284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77285       };
77286     } catch (Dali::DaliException e) {
77287       {
77288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77289       };
77290     } catch (...) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77293       };
77294     }
77295   }
77296
77297   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77298   return jresult;
77299 }
77300
77301
77302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77303   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77304   Dali::Actor arg2 ;
77305   unsigned int arg3 ;
77306   Dali::Actor *argp2 ;
77307
77308   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77309   argp2 = (Dali::Actor *)jarg2;
77310   if (!argp2) {
77311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77312     return ;
77313   }
77314   arg2 = *argp2;
77315   arg3 = (unsigned int)jarg3;
77316   {
77317     try {
77318       (arg1)->ApplyToPage(arg2,arg3);
77319     } catch (std::out_of_range& e) {
77320       {
77321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77322       };
77323     } catch (std::exception& e) {
77324       {
77325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77326       };
77327     } catch (Dali::DaliException e) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77330       };
77331     } catch (...) {
77332       {
77333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77334       };
77335     }
77336   }
77337
77338 }
77339
77340
77341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77342   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77343
77344   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77345   {
77346     try {
77347       delete arg1;
77348     } catch (std::out_of_range& e) {
77349       {
77350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (std::exception& e) {
77353       {
77354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77355       };
77356     } catch (Dali::DaliException e) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77359       };
77360     } catch (...) {
77361       {
77362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77363       };
77364     }
77365   }
77366
77367 }
77368
77369
77370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77371   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77372   Dali::Toolkit::ClampState arg2 ;
77373
77374   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77375   arg2 = (Dali::Toolkit::ClampState)jarg2;
77376   if (arg1) (arg1)->x = arg2;
77377 }
77378
77379
77380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77381   int jresult ;
77382   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77383   Dali::Toolkit::ClampState result;
77384
77385   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77386   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77387   jresult = (int)result;
77388   return jresult;
77389 }
77390
77391
77392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77393   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77394   Dali::Toolkit::ClampState arg2 ;
77395
77396   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77397   arg2 = (Dali::Toolkit::ClampState)jarg2;
77398   if (arg1) (arg1)->y = arg2;
77399 }
77400
77401
77402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77403   int jresult ;
77404   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77405   Dali::Toolkit::ClampState result;
77406
77407   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77408   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77415   void * jresult ;
77416   Dali::Toolkit::ClampState2D *result = 0 ;
77417
77418   {
77419     try {
77420       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77421     } catch (std::out_of_range& e) {
77422       {
77423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77424       };
77425     } catch (std::exception& e) {
77426       {
77427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77428       };
77429     } catch (Dali::DaliException e) {
77430       {
77431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77436       };
77437     }
77438   }
77439
77440   jresult = (void *)result;
77441   return jresult;
77442 }
77443
77444
77445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77446   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77447
77448   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77449   {
77450     try {
77451       delete arg1;
77452     } catch (std::out_of_range& e) {
77453       {
77454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77455       };
77456     } catch (std::exception& e) {
77457       {
77458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77459       };
77460     } catch (Dali::DaliException e) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77463       };
77464     } catch (...) {
77465       {
77466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77467       };
77468     }
77469   }
77470
77471 }
77472
77473
77474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77475   void * jresult ;
77476   float arg1 ;
77477   float arg2 ;
77478   bool arg3 ;
77479   Dali::Toolkit::RulerDomain *result = 0 ;
77480
77481   arg1 = (float)jarg1;
77482   arg2 = (float)jarg2;
77483   arg3 = jarg3 ? true : false;
77484   {
77485     try {
77486       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77487     } catch (std::out_of_range& e) {
77488       {
77489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (std::exception& e) {
77492       {
77493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77494       };
77495     } catch (Dali::DaliException e) {
77496       {
77497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77498       };
77499     } catch (...) {
77500       {
77501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77502       };
77503     }
77504   }
77505
77506   jresult = (void *)result;
77507   return jresult;
77508 }
77509
77510
77511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77512   void * jresult ;
77513   float arg1 ;
77514   float arg2 ;
77515   Dali::Toolkit::RulerDomain *result = 0 ;
77516
77517   arg1 = (float)jarg1;
77518   arg2 = (float)jarg2;
77519   {
77520     try {
77521       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
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 = (void *)result;
77542   return jresult;
77543 }
77544
77545
77546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77547   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77548   float arg2 ;
77549
77550   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77551   arg2 = (float)jarg2;
77552   if (arg1) (arg1)->min = arg2;
77553 }
77554
77555
77556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77557   float jresult ;
77558   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77559   float result;
77560
77561   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77562   result = (float) ((arg1)->min);
77563   jresult = result;
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77569   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77570   float arg2 ;
77571
77572   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77573   arg2 = (float)jarg2;
77574   if (arg1) (arg1)->max = arg2;
77575 }
77576
77577
77578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77579   float jresult ;
77580   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77581   float result;
77582
77583   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77584   result = (float) ((arg1)->max);
77585   jresult = result;
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77591   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77592   bool arg2 ;
77593
77594   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77595   arg2 = jarg2 ? true : false;
77596   if (arg1) (arg1)->enabled = arg2;
77597 }
77598
77599
77600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77601   unsigned int jresult ;
77602   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77603   bool result;
77604
77605   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77606   result = (bool) ((arg1)->enabled);
77607   jresult = result;
77608   return jresult;
77609 }
77610
77611
77612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77613   float jresult ;
77614   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77615   float arg2 ;
77616   float arg3 ;
77617   float arg4 ;
77618   float result;
77619
77620   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77621   arg2 = (float)jarg2;
77622   arg3 = (float)jarg3;
77623   arg4 = (float)jarg4;
77624   {
77625     try {
77626       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77627     } catch (std::out_of_range& e) {
77628       {
77629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77630       };
77631     } catch (std::exception& e) {
77632       {
77633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77634       };
77635     } catch (Dali::DaliException e) {
77636       {
77637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77638       };
77639     } catch (...) {
77640       {
77641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77642       };
77643     }
77644   }
77645
77646   jresult = result;
77647   return jresult;
77648 }
77649
77650
77651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77652   float jresult ;
77653   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77654   float arg2 ;
77655   float arg3 ;
77656   float result;
77657
77658   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77659   arg2 = (float)jarg2;
77660   arg3 = (float)jarg3;
77661   {
77662     try {
77663       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77664     } catch (std::out_of_range& e) {
77665       {
77666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77667       };
77668     } catch (std::exception& e) {
77669       {
77670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77671       };
77672     } catch (Dali::DaliException e) {
77673       {
77674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77675       };
77676     } catch (...) {
77677       {
77678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77679       };
77680     }
77681   }
77682
77683   jresult = result;
77684   return jresult;
77685 }
77686
77687
77688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77689   float jresult ;
77690   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77691   float arg2 ;
77692   float result;
77693
77694   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77695   arg2 = (float)jarg2;
77696   {
77697     try {
77698       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77699     } catch (std::out_of_range& e) {
77700       {
77701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77702       };
77703     } catch (std::exception& e) {
77704       {
77705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77706       };
77707     } catch (Dali::DaliException e) {
77708       {
77709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77710       };
77711     } catch (...) {
77712       {
77713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77714       };
77715     }
77716   }
77717
77718   jresult = result;
77719   return jresult;
77720 }
77721
77722
77723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77724   float jresult ;
77725   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77726   float arg2 ;
77727   float arg3 ;
77728   float arg4 ;
77729   Dali::Toolkit::ClampState *arg5 = 0 ;
77730   float result;
77731
77732   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77733   arg2 = (float)jarg2;
77734   arg3 = (float)jarg3;
77735   arg4 = (float)jarg4;
77736   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77737   if (!arg5) {
77738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77739     return 0;
77740   }
77741   {
77742     try {
77743       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77769   float jresult ;
77770   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77771   float result;
77772
77773   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77774   {
77775     try {
77776       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77784       };
77785     } catch (Dali::DaliException e) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77788       };
77789     } catch (...) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77792       };
77793     }
77794   }
77795
77796   jresult = result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77802   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77803
77804   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77805   {
77806     try {
77807       delete arg1;
77808     } catch (std::out_of_range& e) {
77809       {
77810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77811       };
77812     } catch (std::exception& e) {
77813       {
77814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77815       };
77816     } catch (Dali::DaliException e) {
77817       {
77818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77819       };
77820     } catch (...) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77823       };
77824     }
77825   }
77826
77827 }
77828
77829
77830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77831   float jresult ;
77832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77833   float arg2 ;
77834   float arg3 ;
77835   float result;
77836
77837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77838   arg2 = (float)jarg2;
77839   arg3 = (float)jarg3;
77840   {
77841     try {
77842       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77843     } catch (std::out_of_range& e) {
77844       {
77845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77846       };
77847     } catch (std::exception& e) {
77848       {
77849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77850       };
77851     } catch (Dali::DaliException e) {
77852       {
77853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77854       };
77855     } catch (...) {
77856       {
77857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77858       };
77859     }
77860   }
77861
77862   jresult = result;
77863   return jresult;
77864 }
77865
77866
77867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77868   float jresult ;
77869   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77870   float arg2 ;
77871   float result;
77872
77873   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77874   arg2 = (float)jarg2;
77875   {
77876     try {
77877       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77878     } catch (std::out_of_range& e) {
77879       {
77880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77881       };
77882     } catch (std::exception& e) {
77883       {
77884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77885       };
77886     } catch (Dali::DaliException e) {
77887       {
77888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77889       };
77890     } catch (...) {
77891       {
77892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77893       };
77894     }
77895   }
77896
77897   jresult = result;
77898   return jresult;
77899 }
77900
77901
77902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77903   float jresult ;
77904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77905   unsigned int arg2 ;
77906   unsigned int *arg3 = 0 ;
77907   bool arg4 ;
77908   float result;
77909
77910   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77911   arg2 = (unsigned int)jarg2;
77912   arg3 = (unsigned int *)jarg3;
77913   arg4 = jarg4 ? true : false;
77914   {
77915     try {
77916       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77917     } catch (std::out_of_range& e) {
77918       {
77919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (std::exception& e) {
77922       {
77923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (Dali::DaliException e) {
77926       {
77927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77928       };
77929     } catch (...) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77932       };
77933     }
77934   }
77935
77936   jresult = result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77942   unsigned int jresult ;
77943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77944   float arg2 ;
77945   bool arg3 ;
77946   unsigned int result;
77947
77948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77949   arg2 = (float)jarg2;
77950   arg3 = jarg3 ? true : false;
77951   {
77952     try {
77953       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77954     } catch (std::out_of_range& e) {
77955       {
77956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77957       };
77958     } catch (std::exception& e) {
77959       {
77960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77961       };
77962     } catch (Dali::DaliException e) {
77963       {
77964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77965       };
77966     } catch (...) {
77967       {
77968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77969       };
77970     }
77971   }
77972
77973   jresult = result;
77974   return jresult;
77975 }
77976
77977
77978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77979   unsigned int jresult ;
77980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77981   unsigned int result;
77982
77983   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77984   {
77985     try {
77986       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
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 int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78012   int jresult ;
78013   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78014   Dali::Toolkit::Ruler::RulerType result;
78015
78016   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78017   {
78018     try {
78019       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78020     } catch (std::out_of_range& e) {
78021       {
78022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78023       };
78024     } catch (std::exception& e) {
78025       {
78026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78027       };
78028     } catch (Dali::DaliException e) {
78029       {
78030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78031       };
78032     } catch (...) {
78033       {
78034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78035       };
78036     }
78037   }
78038
78039   jresult = (int)result;
78040   return jresult;
78041 }
78042
78043
78044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78045   unsigned int jresult ;
78046   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78047   bool result;
78048
78049   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78050   {
78051     try {
78052       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78053     } catch (std::out_of_range& e) {
78054       {
78055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78056       };
78057     } catch (std::exception& e) {
78058       {
78059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (Dali::DaliException e) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78064       };
78065     } catch (...) {
78066       {
78067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78068       };
78069     }
78070   }
78071
78072   jresult = result;
78073   return jresult;
78074 }
78075
78076
78077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78078   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78079
78080   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78081   {
78082     try {
78083       (arg1)->Enable();
78084     } catch (std::out_of_range& e) {
78085       {
78086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78087       };
78088     } catch (std::exception& e) {
78089       {
78090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78091       };
78092     } catch (Dali::DaliException e) {
78093       {
78094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78095       };
78096     } catch (...) {
78097       {
78098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78099       };
78100     }
78101   }
78102
78103 }
78104
78105
78106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78107   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78108
78109   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78110   {
78111     try {
78112       (arg1)->Disable();
78113     } catch (std::out_of_range& e) {
78114       {
78115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78116       };
78117     } catch (std::exception& e) {
78118       {
78119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78120       };
78121     } catch (Dali::DaliException e) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78124       };
78125     } catch (...) {
78126       {
78127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78128       };
78129     }
78130   }
78131
78132 }
78133
78134
78135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78136   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78137   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78138   Dali::Toolkit::RulerDomain *argp2 ;
78139
78140   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78141   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78142   if (!argp2) {
78143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78144     return ;
78145   }
78146   arg2 = *argp2;
78147   {
78148     try {
78149       (arg1)->SetDomain(arg2);
78150     } catch (std::out_of_range& e) {
78151       {
78152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78153       };
78154     } catch (std::exception& e) {
78155       {
78156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78157       };
78158     } catch (Dali::DaliException e) {
78159       {
78160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78161       };
78162     } catch (...) {
78163       {
78164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78165       };
78166     }
78167   }
78168
78169 }
78170
78171
78172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78173   void * jresult ;
78174   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78175   Dali::Toolkit::RulerDomain *result = 0 ;
78176
78177   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78178   {
78179     try {
78180       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78181     } catch (std::out_of_range& e) {
78182       {
78183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78184       };
78185     } catch (std::exception& e) {
78186       {
78187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78188       };
78189     } catch (Dali::DaliException e) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78192       };
78193     } catch (...) {
78194       {
78195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78196       };
78197     }
78198   }
78199
78200   jresult = (void *)result;
78201   return jresult;
78202 }
78203
78204
78205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78206   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78207
78208   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78209   {
78210     try {
78211       (arg1)->DisableDomain();
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78219       };
78220     } catch (Dali::DaliException e) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78223       };
78224     } catch (...) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78227       };
78228     }
78229   }
78230
78231 }
78232
78233
78234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78235   float jresult ;
78236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78237   float arg2 ;
78238   float arg3 ;
78239   float arg4 ;
78240   float result;
78241
78242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78243   arg2 = (float)jarg2;
78244   arg3 = (float)jarg3;
78245   arg4 = (float)jarg4;
78246   {
78247     try {
78248       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78249     } catch (std::out_of_range& e) {
78250       {
78251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78252       };
78253     } catch (std::exception& e) {
78254       {
78255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78256       };
78257     } catch (Dali::DaliException e) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78260       };
78261     } catch (...) {
78262       {
78263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78264       };
78265     }
78266   }
78267
78268   jresult = result;
78269   return jresult;
78270 }
78271
78272
78273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78274   float jresult ;
78275   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78276   float arg2 ;
78277   float arg3 ;
78278   float result;
78279
78280   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78281   arg2 = (float)jarg2;
78282   arg3 = (float)jarg3;
78283   {
78284     try {
78285       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78286     } catch (std::out_of_range& e) {
78287       {
78288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78289       };
78290     } catch (std::exception& e) {
78291       {
78292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78293       };
78294     } catch (Dali::DaliException e) {
78295       {
78296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78297       };
78298     } catch (...) {
78299       {
78300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78301       };
78302     }
78303   }
78304
78305   jresult = result;
78306   return jresult;
78307 }
78308
78309
78310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78311   float jresult ;
78312   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78313   float arg2 ;
78314   float result;
78315
78316   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78317   arg2 = (float)jarg2;
78318   {
78319     try {
78320       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78321     } catch (std::out_of_range& e) {
78322       {
78323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (std::exception& e) {
78326       {
78327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78328       };
78329     } catch (Dali::DaliException e) {
78330       {
78331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78332       };
78333     } catch (...) {
78334       {
78335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78336       };
78337     }
78338   }
78339
78340   jresult = result;
78341   return jresult;
78342 }
78343
78344
78345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78346   float jresult ;
78347   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78348   float arg2 ;
78349   float arg3 ;
78350   float arg4 ;
78351   Dali::Toolkit::ClampState *arg5 = 0 ;
78352   float result;
78353
78354   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78355   arg2 = (float)jarg2;
78356   arg3 = (float)jarg3;
78357   arg4 = (float)jarg4;
78358   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78359   if (!arg5) {
78360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78361     return 0;
78362   }
78363   {
78364     try {
78365       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78366     } catch (std::out_of_range& e) {
78367       {
78368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78369       };
78370     } catch (std::exception& e) {
78371       {
78372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78373       };
78374     } catch (Dali::DaliException e) {
78375       {
78376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78377       };
78378     } catch (...) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78381       };
78382     }
78383   }
78384
78385   jresult = result;
78386   return jresult;
78387 }
78388
78389
78390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78391   float jresult ;
78392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78393   float arg2 ;
78394   float arg3 ;
78395   float arg4 ;
78396   float arg5 ;
78397   float result;
78398
78399   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78400   arg2 = (float)jarg2;
78401   arg3 = (float)jarg3;
78402   arg4 = (float)jarg4;
78403   arg5 = (float)jarg5;
78404   {
78405     try {
78406       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78414       };
78415     } catch (Dali::DaliException e) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78418       };
78419     } catch (...) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78422       };
78423     }
78424   }
78425
78426   jresult = result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78432   float jresult ;
78433   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78434   float arg2 ;
78435   float arg3 ;
78436   float arg4 ;
78437   float result;
78438
78439   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78440   arg2 = (float)jarg2;
78441   arg3 = (float)jarg3;
78442   arg4 = (float)jarg4;
78443   {
78444     try {
78445       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78446     } catch (std::out_of_range& e) {
78447       {
78448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78449       };
78450     } catch (std::exception& e) {
78451       {
78452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78453       };
78454     } catch (Dali::DaliException e) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78457       };
78458     } catch (...) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78461       };
78462     }
78463   }
78464
78465   jresult = result;
78466   return jresult;
78467 }
78468
78469
78470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78471   float jresult ;
78472   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78473   float arg2 ;
78474   float arg3 ;
78475   float result;
78476
78477   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78478   arg2 = (float)jarg2;
78479   arg3 = (float)jarg3;
78480   {
78481     try {
78482       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78483     } catch (std::out_of_range& e) {
78484       {
78485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78486       };
78487     } catch (std::exception& e) {
78488       {
78489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78490       };
78491     } catch (Dali::DaliException e) {
78492       {
78493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78494       };
78495     } catch (...) {
78496       {
78497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78498       };
78499     }
78500   }
78501
78502   jresult = result;
78503   return jresult;
78504 }
78505
78506
78507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78508   float jresult ;
78509   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78510   float arg2 ;
78511   float result;
78512
78513   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78514   arg2 = (float)jarg2;
78515   {
78516     try {
78517       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78518     } catch (std::out_of_range& e) {
78519       {
78520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78521       };
78522     } catch (std::exception& e) {
78523       {
78524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78525       };
78526     } catch (Dali::DaliException e) {
78527       {
78528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78529       };
78530     } catch (...) {
78531       {
78532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78533       };
78534     }
78535   }
78536
78537   jresult = result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78543   float jresult ;
78544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78545   float arg2 ;
78546   float arg3 ;
78547   float arg4 ;
78548   float arg5 ;
78549   Dali::Toolkit::ClampState *arg6 = 0 ;
78550   float result;
78551
78552   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78553   arg2 = (float)jarg2;
78554   arg3 = (float)jarg3;
78555   arg4 = (float)jarg4;
78556   arg5 = (float)jarg5;
78557   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78558   if (!arg6) {
78559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78560     return 0;
78561   }
78562   {
78563     try {
78564       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78565     } catch (std::out_of_range& e) {
78566       {
78567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (std::exception& e) {
78570       {
78571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (Dali::DaliException e) {
78574       {
78575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78576       };
78577     } catch (...) {
78578       {
78579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78580       };
78581     }
78582   }
78583
78584   jresult = result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78590   void * jresult ;
78591   Dali::Toolkit::DefaultRuler *result = 0 ;
78592
78593   {
78594     try {
78595       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78596     } catch (std::out_of_range& e) {
78597       {
78598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78599       };
78600     } catch (std::exception& e) {
78601       {
78602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78603       };
78604     } catch (Dali::DaliException e) {
78605       {
78606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78607       };
78608     } catch (...) {
78609       {
78610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78611       };
78612     }
78613   }
78614
78615   jresult = (void *)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78621   float jresult ;
78622   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78623   float arg2 ;
78624   float arg3 ;
78625   float result;
78626
78627   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78628   arg2 = (float)jarg2;
78629   arg3 = (float)jarg3;
78630   {
78631     try {
78632       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78633     } catch (std::out_of_range& e) {
78634       {
78635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78636       };
78637     } catch (std::exception& e) {
78638       {
78639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78640       };
78641     } catch (Dali::DaliException e) {
78642       {
78643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78644       };
78645     } catch (...) {
78646       {
78647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78648       };
78649     }
78650   }
78651
78652   jresult = result;
78653   return jresult;
78654 }
78655
78656
78657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78658   float jresult ;
78659   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78660   unsigned int arg2 ;
78661   unsigned int *arg3 = 0 ;
78662   bool arg4 ;
78663   float result;
78664
78665   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78666   arg2 = (unsigned int)jarg2;
78667   arg3 = (unsigned int *)jarg3;
78668   arg4 = jarg4 ? true : false;
78669   {
78670     try {
78671       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78672     } catch (std::out_of_range& e) {
78673       {
78674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78675       };
78676     } catch (std::exception& e) {
78677       {
78678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78679       };
78680     } catch (Dali::DaliException e) {
78681       {
78682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78683       };
78684     } catch (...) {
78685       {
78686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78687       };
78688     }
78689   }
78690
78691   jresult = result;
78692   return jresult;
78693 }
78694
78695
78696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78697   unsigned int jresult ;
78698   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78699   float arg2 ;
78700   bool arg3 ;
78701   unsigned int result;
78702
78703   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78704   arg2 = (float)jarg2;
78705   arg3 = jarg3 ? true : false;
78706   {
78707     try {
78708       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78709     } catch (std::out_of_range& e) {
78710       {
78711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78712       };
78713     } catch (std::exception& e) {
78714       {
78715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78716       };
78717     } catch (Dali::DaliException e) {
78718       {
78719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78720       };
78721     } catch (...) {
78722       {
78723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78724       };
78725     }
78726   }
78727
78728   jresult = result;
78729   return jresult;
78730 }
78731
78732
78733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78734   unsigned int jresult ;
78735   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78736   unsigned int result;
78737
78738   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78739   {
78740     try {
78741       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78742     } catch (std::out_of_range& e) {
78743       {
78744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78745       };
78746     } catch (std::exception& e) {
78747       {
78748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78749       };
78750     } catch (Dali::DaliException e) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78753       };
78754     } catch (...) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78757       };
78758     }
78759   }
78760
78761   jresult = result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78767   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78768
78769   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78770   {
78771     try {
78772       delete arg1;
78773     } catch (std::out_of_range& e) {
78774       {
78775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78776       };
78777     } catch (std::exception& e) {
78778       {
78779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78780       };
78781     } catch (Dali::DaliException e) {
78782       {
78783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78784       };
78785     } catch (...) {
78786       {
78787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78788       };
78789     }
78790   }
78791
78792 }
78793
78794
78795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78796   void * jresult ;
78797   float arg1 ;
78798   Dali::Toolkit::FixedRuler *result = 0 ;
78799
78800   arg1 = (float)jarg1;
78801   {
78802     try {
78803       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78804     } catch (std::out_of_range& e) {
78805       {
78806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78807       };
78808     } catch (std::exception& e) {
78809       {
78810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (Dali::DaliException e) {
78813       {
78814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822
78823   jresult = (void *)result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78829   void * jresult ;
78830   Dali::Toolkit::FixedRuler *result = 0 ;
78831
78832   {
78833     try {
78834       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78835     } catch (std::out_of_range& e) {
78836       {
78837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78838       };
78839     } catch (std::exception& e) {
78840       {
78841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78842       };
78843     } catch (Dali::DaliException e) {
78844       {
78845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78850       };
78851     }
78852   }
78853
78854   jresult = (void *)result;
78855   return jresult;
78856 }
78857
78858
78859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78860   float jresult ;
78861   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78862   float arg2 ;
78863   float arg3 ;
78864   float result;
78865
78866   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78867   arg2 = (float)jarg2;
78868   arg3 = (float)jarg3;
78869   {
78870     try {
78871       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78872     } catch (std::out_of_range& e) {
78873       {
78874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78875       };
78876     } catch (std::exception& e) {
78877       {
78878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78879       };
78880     } catch (Dali::DaliException e) {
78881       {
78882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78883       };
78884     } catch (...) {
78885       {
78886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78887       };
78888     }
78889   }
78890
78891   jresult = result;
78892   return jresult;
78893 }
78894
78895
78896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78897   float jresult ;
78898   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78899   unsigned int arg2 ;
78900   unsigned int *arg3 = 0 ;
78901   bool arg4 ;
78902   float result;
78903
78904   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78905   arg2 = (unsigned int)jarg2;
78906   arg3 = (unsigned int *)jarg3;
78907   arg4 = jarg4 ? true : false;
78908   {
78909     try {
78910       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78911     } catch (std::out_of_range& e) {
78912       {
78913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78914       };
78915     } catch (std::exception& e) {
78916       {
78917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78918       };
78919     } catch (Dali::DaliException e) {
78920       {
78921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78922       };
78923     } catch (...) {
78924       {
78925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78926       };
78927     }
78928   }
78929
78930   jresult = result;
78931   return jresult;
78932 }
78933
78934
78935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78936   unsigned int jresult ;
78937   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78938   float arg2 ;
78939   bool arg3 ;
78940   unsigned int result;
78941
78942   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78943   arg2 = (float)jarg2;
78944   arg3 = jarg3 ? true : false;
78945   {
78946     try {
78947       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78948     } catch (std::out_of_range& e) {
78949       {
78950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78951       };
78952     } catch (std::exception& e) {
78953       {
78954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78955       };
78956     } catch (Dali::DaliException e) {
78957       {
78958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78959       };
78960     } catch (...) {
78961       {
78962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78963       };
78964     }
78965   }
78966
78967   jresult = result;
78968   return jresult;
78969 }
78970
78971
78972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78973   unsigned int jresult ;
78974   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78975   unsigned int result;
78976
78977   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78978   {
78979     try {
78980       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (Dali::DaliException e) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78992       };
78993     } catch (...) {
78994       {
78995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78996       };
78997     }
78998   }
78999
79000   jresult = result;
79001   return jresult;
79002 }
79003
79004
79005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79006   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79007
79008   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79009   {
79010     try {
79011       delete arg1;
79012     } catch (std::out_of_range& e) {
79013       {
79014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79015       };
79016     } catch (std::exception& e) {
79017       {
79018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79019       };
79020     } catch (Dali::DaliException e) {
79021       {
79022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79023       };
79024     } catch (...) {
79025       {
79026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79027       };
79028     }
79029   }
79030
79031 }
79032
79033
79034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79035   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79036   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79037
79038   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79039   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79040   if (arg1) (arg1)->scale = *arg2;
79041 }
79042
79043
79044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79045   void * jresult ;
79046   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79047   Dali::Toolkit::ClampState2D *result = 0 ;
79048
79049   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79050   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79051   jresult = (void *)result;
79052   return jresult;
79053 }
79054
79055
79056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79057   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79058   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79059
79060   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79061   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79062   if (arg1) (arg1)->position = *arg2;
79063 }
79064
79065
79066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79067   void * jresult ;
79068   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79069   Dali::Toolkit::ClampState2D *result = 0 ;
79070
79071   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79072   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79073   jresult = (void *)result;
79074   return jresult;
79075 }
79076
79077
79078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79079   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79080   Dali::Toolkit::ClampState arg2 ;
79081
79082   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79083   arg2 = (Dali::Toolkit::ClampState)jarg2;
79084   if (arg1) (arg1)->rotation = arg2;
79085 }
79086
79087
79088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79089   int jresult ;
79090   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79091   Dali::Toolkit::ClampState result;
79092
79093   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79094   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79095   jresult = (int)result;
79096   return jresult;
79097 }
79098
79099
79100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79101   void * jresult ;
79102   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79103
79104   {
79105     try {
79106       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79107     } catch (std::out_of_range& e) {
79108       {
79109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79110       };
79111     } catch (std::exception& e) {
79112       {
79113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79114       };
79115     } catch (Dali::DaliException e) {
79116       {
79117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79118       };
79119     } catch (...) {
79120       {
79121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79122       };
79123     }
79124   }
79125
79126   jresult = (void *)result;
79127   return jresult;
79128 }
79129
79130
79131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79132   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79133
79134   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79135   {
79136     try {
79137       delete arg1;
79138     } catch (std::out_of_range& e) {
79139       {
79140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79141       };
79142     } catch (std::exception& e) {
79143       {
79144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79145       };
79146     } catch (Dali::DaliException e) {
79147       {
79148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79153       };
79154     }
79155   }
79156
79157 }
79158
79159
79160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79161   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79162   Dali::Toolkit::SnapType arg2 ;
79163
79164   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79165   arg2 = (Dali::Toolkit::SnapType)jarg2;
79166   if (arg1) (arg1)->type = arg2;
79167 }
79168
79169
79170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79171   int jresult ;
79172   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79173   Dali::Toolkit::SnapType result;
79174
79175   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79176   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79177   jresult = (int)result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79183   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79184   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79185
79186   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79187   arg2 = (Dali::Vector2 *)jarg2;
79188   if (arg1) (arg1)->position = *arg2;
79189 }
79190
79191
79192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79193   void * jresult ;
79194   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79195   Dali::Vector2 *result = 0 ;
79196
79197   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79198   result = (Dali::Vector2 *)& ((arg1)->position);
79199   jresult = (void *)result;
79200   return jresult;
79201 }
79202
79203
79204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79205   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79206   float arg2 ;
79207
79208   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79209   arg2 = (float)jarg2;
79210   if (arg1) (arg1)->duration = arg2;
79211 }
79212
79213
79214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79215   float jresult ;
79216   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79217   float result;
79218
79219   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79220   result = (float) ((arg1)->duration);
79221   jresult = result;
79222   return jresult;
79223 }
79224
79225
79226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79227   void * jresult ;
79228   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79229
79230   {
79231     try {
79232       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79233     } catch (std::out_of_range& e) {
79234       {
79235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79236       };
79237     } catch (std::exception& e) {
79238       {
79239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (Dali::DaliException e) {
79242       {
79243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251
79252   jresult = (void *)result;
79253   return jresult;
79254 }
79255
79256
79257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79258   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79259
79260   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79261   {
79262     try {
79263       delete arg1;
79264     } catch (std::out_of_range& e) {
79265       {
79266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79267       };
79268     } catch (std::exception& e) {
79269       {
79270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79271       };
79272     } catch (Dali::DaliException e) {
79273       {
79274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79275       };
79276     } catch (...) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79279       };
79280     }
79281   }
79282
79283 }
79284
79285
79286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79287   int jresult ;
79288   int result;
79289
79290   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79291   jresult = (int)result;
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79297   int jresult ;
79298   int result;
79299
79300   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79301   jresult = (int)result;
79302   return jresult;
79303 }
79304
79305
79306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79307   int jresult ;
79308   int result;
79309
79310   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79311   jresult = (int)result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79317   int jresult ;
79318   int result;
79319
79320   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79321   jresult = (int)result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79327   int jresult ;
79328   int result;
79329
79330   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79331   jresult = (int)result;
79332   return jresult;
79333 }
79334
79335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79336   int jresult ;
79337   int result;
79338
79339   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79340   jresult = (int)result;
79341   return jresult;
79342 }
79343
79344
79345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79346   int jresult ;
79347   int result;
79348
79349   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79350   jresult = (int)result;
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79356   int jresult ;
79357   int result;
79358
79359   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79360   jresult = (int)result;
79361   return jresult;
79362 }
79363
79364
79365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79366   int jresult ;
79367   int result;
79368
79369   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79370   jresult = (int)result;
79371   return jresult;
79372 }
79373
79374
79375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79376   int jresult ;
79377   int result;
79378
79379   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79380   jresult = (int)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79386   int jresult ;
79387   int result;
79388
79389   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79390   jresult = (int)result;
79391   return jresult;
79392 }
79393
79394
79395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79396   int jresult ;
79397   int result;
79398
79399   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79400   jresult = (int)result;
79401   return jresult;
79402 }
79403
79404
79405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79406   int jresult ;
79407   int result;
79408
79409   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79410   jresult = (int)result;
79411   return jresult;
79412 }
79413
79414
79415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79416   int jresult ;
79417   int result;
79418
79419   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79420   jresult = (int)result;
79421   return jresult;
79422 }
79423
79424
79425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79426   int jresult ;
79427   int result;
79428
79429   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79430   jresult = (int)result;
79431   return jresult;
79432 }
79433
79434
79435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79436   int jresult ;
79437   int result;
79438
79439   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79440   jresult = (int)result;
79441   return jresult;
79442 }
79443
79444
79445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79446   int jresult ;
79447   int result;
79448
79449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79450   jresult = (int)result;
79451   return jresult;
79452 }
79453
79454
79455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79456   int jresult ;
79457   int result;
79458
79459   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79460   jresult = (int)result;
79461   return jresult;
79462 }
79463
79464
79465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79466   int jresult ;
79467   int result;
79468
79469   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79470   jresult = (int)result;
79471   return jresult;
79472 }
79473
79474
79475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79476   int jresult ;
79477   int result;
79478
79479   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79480   jresult = (int)result;
79481   return jresult;
79482 }
79483
79484
79485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79486   int jresult ;
79487   int result;
79488
79489   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79490   jresult = (int)result;
79491   return jresult;
79492 }
79493
79494
79495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79496   int jresult ;
79497   int result;
79498
79499   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79500   jresult = (int)result;
79501   return jresult;
79502 }
79503
79504
79505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79506   int jresult ;
79507   int result;
79508
79509   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79510   jresult = (int)result;
79511   return jresult;
79512 }
79513
79514
79515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79516   int jresult ;
79517   int result;
79518
79519   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79520   jresult = (int)result;
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79526   int jresult ;
79527   int result;
79528
79529   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79530   jresult = (int)result;
79531   return jresult;
79532 }
79533
79534
79535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79536   int jresult ;
79537   int result;
79538
79539   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79540   jresult = (int)result;
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79546   void * jresult ;
79547   Dali::Toolkit::ScrollView::Property *result = 0 ;
79548
79549   {
79550     try {
79551       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79552     } catch (std::out_of_range& e) {
79553       {
79554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79555       };
79556     } catch (std::exception& e) {
79557       {
79558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79559       };
79560     } catch (Dali::DaliException e) {
79561       {
79562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79563       };
79564     } catch (...) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79567       };
79568     }
79569   }
79570
79571   jresult = (void *)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79577   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79578
79579   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79580   {
79581     try {
79582       delete arg1;
79583     } catch (std::out_of_range& e) {
79584       {
79585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79586       };
79587     } catch (std::exception& e) {
79588       {
79589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79590       };
79591     } catch (Dali::DaliException e) {
79592       {
79593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79594       };
79595     } catch (...) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79598       };
79599     }
79600   }
79601
79602 }
79603
79604
79605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79606   void * jresult ;
79607   Dali::Toolkit::ScrollView *result = 0 ;
79608
79609   {
79610     try {
79611       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79612     } catch (std::out_of_range& e) {
79613       {
79614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79615       };
79616     } catch (std::exception& e) {
79617       {
79618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (Dali::DaliException e) {
79621       {
79622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630
79631   jresult = (void *)result;
79632   return jresult;
79633 }
79634
79635
79636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79637   void * jresult ;
79638   Dali::Toolkit::ScrollView *arg1 = 0 ;
79639   Dali::Toolkit::ScrollView *result = 0 ;
79640
79641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79642   if (!arg1) {
79643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79644     return 0;
79645   }
79646   {
79647     try {
79648       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79649     } catch (std::out_of_range& e) {
79650       {
79651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (std::exception& e) {
79654       {
79655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (Dali::DaliException e) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79664       };
79665     }
79666   }
79667
79668   jresult = (void *)result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79674   void * jresult ;
79675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79676   Dali::Toolkit::ScrollView *arg2 = 0 ;
79677   Dali::Toolkit::ScrollView *result = 0 ;
79678
79679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79680   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79681   if (!arg2) {
79682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79683     return 0;
79684   }
79685   {
79686     try {
79687       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79688     } catch (std::out_of_range& e) {
79689       {
79690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79691       };
79692     } catch (std::exception& e) {
79693       {
79694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79695       };
79696     } catch (Dali::DaliException e) {
79697       {
79698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79699       };
79700     } catch (...) {
79701       {
79702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79703       };
79704     }
79705   }
79706
79707   jresult = (void *)result;
79708   return jresult;
79709 }
79710
79711
79712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79714
79715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79716   {
79717     try {
79718       delete arg1;
79719     } catch (std::out_of_range& e) {
79720       {
79721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79722       };
79723     } catch (std::exception& e) {
79724       {
79725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79726       };
79727     } catch (Dali::DaliException e) {
79728       {
79729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79730       };
79731     } catch (...) {
79732       {
79733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79734       };
79735     }
79736   }
79737
79738 }
79739
79740
79741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79742   void * jresult ;
79743   Dali::Toolkit::ScrollView result;
79744
79745   {
79746     try {
79747       result = Dali::Toolkit::ScrollView::New();
79748     } catch (std::out_of_range& e) {
79749       {
79750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79751       };
79752     } catch (std::exception& e) {
79753       {
79754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79755       };
79756     } catch (Dali::DaliException e) {
79757       {
79758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79759       };
79760     } catch (...) {
79761       {
79762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79763       };
79764     }
79765   }
79766
79767   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79773   void * jresult ;
79774   Dali::BaseHandle arg1 ;
79775   Dali::BaseHandle *argp1 ;
79776   Dali::Toolkit::ScrollView result;
79777
79778   argp1 = (Dali::BaseHandle *)jarg1;
79779   if (!argp1) {
79780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79781     return 0;
79782   }
79783   arg1 = *argp1;
79784   {
79785     try {
79786       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79787     } catch (std::out_of_range& e) {
79788       {
79789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79790       };
79791     } catch (std::exception& e) {
79792       {
79793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (Dali::DaliException e) {
79796       {
79797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79802       };
79803     }
79804   }
79805
79806   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79812   void * jresult ;
79813   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79814   Dali::AlphaFunction result;
79815
79816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79817   {
79818     try {
79819       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79820     } catch (std::out_of_range& e) {
79821       {
79822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79823       };
79824     } catch (std::exception& e) {
79825       {
79826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79827       };
79828     } catch (Dali::DaliException e) {
79829       {
79830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79831       };
79832     } catch (...) {
79833       {
79834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79835       };
79836     }
79837   }
79838
79839   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79840   return jresult;
79841 }
79842
79843
79844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79846   Dali::AlphaFunction arg2 ;
79847   Dali::AlphaFunction *argp2 ;
79848
79849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79850   argp2 = (Dali::AlphaFunction *)jarg2;
79851   if (!argp2) {
79852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79853     return ;
79854   }
79855   arg2 = *argp2;
79856   {
79857     try {
79858       (arg1)->SetScrollSnapAlphaFunction(arg2);
79859     } catch (std::out_of_range& e) {
79860       {
79861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79862       };
79863     } catch (std::exception& e) {
79864       {
79865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79866       };
79867     } catch (Dali::DaliException e) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79870       };
79871     } catch (...) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79874       };
79875     }
79876   }
79877
79878 }
79879
79880
79881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79882   void * jresult ;
79883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79884   Dali::AlphaFunction result;
79885
79886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79887   {
79888     try {
79889       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79890     } catch (std::out_of_range& e) {
79891       {
79892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79893       };
79894     } catch (std::exception& e) {
79895       {
79896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79897       };
79898     } catch (Dali::DaliException e) {
79899       {
79900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79901       };
79902     } catch (...) {
79903       {
79904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79905       };
79906     }
79907   }
79908
79909   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79910   return jresult;
79911 }
79912
79913
79914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79916   Dali::AlphaFunction arg2 ;
79917   Dali::AlphaFunction *argp2 ;
79918
79919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79920   argp2 = (Dali::AlphaFunction *)jarg2;
79921   if (!argp2) {
79922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79923     return ;
79924   }
79925   arg2 = *argp2;
79926   {
79927     try {
79928       (arg1)->SetScrollFlickAlphaFunction(arg2);
79929     } catch (std::out_of_range& e) {
79930       {
79931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79932       };
79933     } catch (std::exception& e) {
79934       {
79935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79936       };
79937     } catch (Dali::DaliException e) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79940       };
79941     } catch (...) {
79942       {
79943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79944       };
79945     }
79946   }
79947
79948 }
79949
79950
79951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79952   float jresult ;
79953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79954   float result;
79955
79956   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79957   {
79958     try {
79959       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79960     } catch (std::out_of_range& e) {
79961       {
79962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79963       };
79964     } catch (std::exception& e) {
79965       {
79966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79967       };
79968     } catch (Dali::DaliException e) {
79969       {
79970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79971       };
79972     } catch (...) {
79973       {
79974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79975       };
79976     }
79977   }
79978
79979   jresult = result;
79980   return jresult;
79981 }
79982
79983
79984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79986   float arg2 ;
79987
79988   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79989   arg2 = (float)jarg2;
79990   {
79991     try {
79992       (arg1)->SetScrollSnapDuration(arg2);
79993     } catch (std::out_of_range& e) {
79994       {
79995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79996       };
79997     } catch (std::exception& e) {
79998       {
79999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80000       };
80001     } catch (Dali::DaliException e) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80004       };
80005     } catch (...) {
80006       {
80007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80008       };
80009     }
80010   }
80011
80012 }
80013
80014
80015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80016   float jresult ;
80017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80018   float result;
80019
80020   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80021   {
80022     try {
80023       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80024     } catch (std::out_of_range& e) {
80025       {
80026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80027       };
80028     } catch (std::exception& e) {
80029       {
80030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80031       };
80032     } catch (Dali::DaliException e) {
80033       {
80034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80035       };
80036     } catch (...) {
80037       {
80038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80039       };
80040     }
80041   }
80042
80043   jresult = result;
80044   return jresult;
80045 }
80046
80047
80048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80049   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80050   float arg2 ;
80051
80052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80053   arg2 = (float)jarg2;
80054   {
80055     try {
80056       (arg1)->SetScrollFlickDuration(arg2);
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80064       };
80065     } catch (Dali::DaliException e) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80072       };
80073     }
80074   }
80075
80076 }
80077
80078
80079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80081   Dali::Toolkit::RulerPtr arg2 ;
80082   Dali::Toolkit::RulerPtr *argp2 ;
80083
80084   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80085   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80086   if (!argp2) {
80087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80088     return ;
80089   }
80090   arg2 = *argp2;
80091   {
80092     try {
80093       (arg1)->SetRulerX(arg2);
80094     } catch (std::out_of_range& e) {
80095       {
80096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80097       };
80098     } catch (std::exception& e) {
80099       {
80100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80101       };
80102     } catch (Dali::DaliException e) {
80103       {
80104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80105       };
80106     } catch (...) {
80107       {
80108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80109       };
80110     }
80111   }
80112
80113 }
80114
80115
80116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80117   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80118   Dali::Toolkit::RulerPtr arg2 ;
80119   Dali::Toolkit::RulerPtr *argp2 ;
80120
80121   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80122   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80123   if (!argp2) {
80124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80125     return ;
80126   }
80127   arg2 = *argp2;
80128   {
80129     try {
80130       (arg1)->SetRulerY(arg2);
80131     } catch (std::out_of_range& e) {
80132       {
80133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (std::exception& e) {
80136       {
80137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80138       };
80139     } catch (Dali::DaliException e) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80142       };
80143     } catch (...) {
80144       {
80145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80146       };
80147     }
80148   }
80149
80150 }
80151
80152
80153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80155   bool arg2 ;
80156
80157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80158   arg2 = jarg2 ? true : false;
80159   {
80160     try {
80161       (arg1)->SetScrollSensitive(arg2);
80162     } catch (std::out_of_range& e) {
80163       {
80164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80165       };
80166     } catch (std::exception& e) {
80167       {
80168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80169       };
80170     } catch (Dali::DaliException e) {
80171       {
80172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80173       };
80174     } catch (...) {
80175       {
80176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80177       };
80178     }
80179   }
80180
80181 }
80182
80183
80184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80186   float arg2 ;
80187   float arg3 ;
80188
80189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80190   arg2 = (float)jarg2;
80191   arg3 = (float)jarg3;
80192   {
80193     try {
80194       (arg1)->SetMaxOvershoot(arg2,arg3);
80195     } catch (std::out_of_range& e) {
80196       {
80197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80198       };
80199     } catch (std::exception& e) {
80200       {
80201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80202       };
80203     } catch (Dali::DaliException e) {
80204       {
80205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80206       };
80207     } catch (...) {
80208       {
80209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80210       };
80211     }
80212   }
80213
80214 }
80215
80216
80217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80218   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80219   Dali::AlphaFunction arg2 ;
80220   Dali::AlphaFunction *argp2 ;
80221
80222   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80223   argp2 = (Dali::AlphaFunction *)jarg2;
80224   if (!argp2) {
80225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80226     return ;
80227   }
80228   arg2 = *argp2;
80229   {
80230     try {
80231       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80232     } catch (std::out_of_range& e) {
80233       {
80234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80235       };
80236     } catch (std::exception& e) {
80237       {
80238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80239       };
80240     } catch (Dali::DaliException e) {
80241       {
80242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80243       };
80244     } catch (...) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80247       };
80248     }
80249   }
80250
80251 }
80252
80253
80254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80255   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80256   float arg2 ;
80257
80258   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80259   arg2 = (float)jarg2;
80260   {
80261     try {
80262       (arg1)->SetSnapOvershootDuration(arg2);
80263     } catch (std::out_of_range& e) {
80264       {
80265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80266       };
80267     } catch (std::exception& e) {
80268       {
80269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80270       };
80271     } catch (Dali::DaliException e) {
80272       {
80273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80274       };
80275     } catch (...) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80278       };
80279     }
80280   }
80281
80282 }
80283
80284
80285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80287   bool arg2 ;
80288
80289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80290   arg2 = jarg2 ? true : false;
80291   {
80292     try {
80293       (arg1)->SetActorAutoSnap(arg2);
80294     } catch (std::out_of_range& e) {
80295       {
80296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80297       };
80298     } catch (std::exception& e) {
80299       {
80300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80301       };
80302     } catch (Dali::DaliException e) {
80303       {
80304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80305       };
80306     } catch (...) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80309       };
80310     }
80311   }
80312
80313 }
80314
80315
80316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80318   bool arg2 ;
80319
80320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80321   arg2 = jarg2 ? true : false;
80322   {
80323     try {
80324       (arg1)->SetWrapMode(arg2);
80325     } catch (std::out_of_range& e) {
80326       {
80327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80328       };
80329     } catch (std::exception& e) {
80330       {
80331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80332       };
80333     } catch (Dali::DaliException e) {
80334       {
80335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80336       };
80337     } catch (...) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80340       };
80341     }
80342   }
80343
80344 }
80345
80346
80347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80348   int jresult ;
80349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80350   int result;
80351
80352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80353   {
80354     try {
80355       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80356     } catch (std::out_of_range& e) {
80357       {
80358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80359       };
80360     } catch (std::exception& e) {
80361       {
80362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80363       };
80364     } catch (Dali::DaliException e) {
80365       {
80366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80367       };
80368     } catch (...) {
80369       {
80370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80371       };
80372     }
80373   }
80374
80375   jresult = result;
80376   return jresult;
80377 }
80378
80379
80380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80381   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80382   int arg2 ;
80383
80384   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80385   arg2 = (int)jarg2;
80386   {
80387     try {
80388       (arg1)->SetScrollUpdateDistance(arg2);
80389     } catch (std::out_of_range& e) {
80390       {
80391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80392       };
80393     } catch (std::exception& e) {
80394       {
80395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80396       };
80397     } catch (Dali::DaliException e) {
80398       {
80399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80400       };
80401     } catch (...) {
80402       {
80403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80404       };
80405     }
80406   }
80407
80408 }
80409
80410
80411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80412   unsigned int jresult ;
80413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80414   bool result;
80415
80416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80417   {
80418     try {
80419       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80427       };
80428     } catch (Dali::DaliException e) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80431       };
80432     } catch (...) {
80433       {
80434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80435       };
80436     }
80437   }
80438
80439   jresult = result;
80440   return jresult;
80441 }
80442
80443
80444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80446   bool arg2 ;
80447
80448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80449   arg2 = jarg2 ? true : false;
80450   {
80451     try {
80452       (arg1)->SetAxisAutoLock(arg2);
80453     } catch (std::out_of_range& e) {
80454       {
80455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80456       };
80457     } catch (std::exception& e) {
80458       {
80459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80460       };
80461     } catch (Dali::DaliException e) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80464       };
80465     } catch (...) {
80466       {
80467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80468       };
80469     }
80470   }
80471
80472 }
80473
80474
80475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80476   float jresult ;
80477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80478   float result;
80479
80480   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80481   {
80482     try {
80483       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80484     } catch (std::out_of_range& e) {
80485       {
80486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80487       };
80488     } catch (std::exception& e) {
80489       {
80490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80491       };
80492     } catch (Dali::DaliException e) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80495       };
80496     } catch (...) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80499       };
80500     }
80501   }
80502
80503   jresult = result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80510   float arg2 ;
80511
80512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80513   arg2 = (float)jarg2;
80514   {
80515     try {
80516       (arg1)->SetAxisAutoLockGradient(arg2);
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80524       };
80525     } catch (Dali::DaliException e) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80532       };
80533     }
80534   }
80535
80536 }
80537
80538
80539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80540   float jresult ;
80541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80542   float result;
80543
80544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80545   {
80546     try {
80547       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80548     } catch (std::out_of_range& e) {
80549       {
80550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (std::exception& e) {
80553       {
80554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (Dali::DaliException e) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80559       };
80560     } catch (...) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80563       };
80564     }
80565   }
80566
80567   jresult = result;
80568   return jresult;
80569 }
80570
80571
80572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80574   float arg2 ;
80575
80576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80577   arg2 = (float)jarg2;
80578   {
80579     try {
80580       (arg1)->SetFrictionCoefficient(arg2);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (Dali::DaliException e) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80596       };
80597     }
80598   }
80599
80600 }
80601
80602
80603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80604   float jresult ;
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   float result;
80607
80608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80609   {
80610     try {
80611       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80612     } catch (std::out_of_range& e) {
80613       {
80614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (std::exception& e) {
80617       {
80618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80619       };
80620     } catch (Dali::DaliException e) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80623       };
80624     } catch (...) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80627       };
80628     }
80629   }
80630
80631   jresult = result;
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80638   float arg2 ;
80639
80640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80641   arg2 = (float)jarg2;
80642   {
80643     try {
80644       (arg1)->SetFlickSpeedCoefficient(arg2);
80645     } catch (std::out_of_range& e) {
80646       {
80647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80648       };
80649     } catch (std::exception& e) {
80650       {
80651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80652       };
80653     } catch (Dali::DaliException e) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80656       };
80657     } catch (...) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80660       };
80661     }
80662   }
80663
80664 }
80665
80666
80667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80668   void * jresult ;
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   Dali::Vector2 result;
80671
80672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80673   {
80674     try {
80675       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80683       };
80684     } catch (Dali::DaliException e) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80687       };
80688     } catch (...) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80691       };
80692     }
80693   }
80694
80695   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80702   Dali::Vector2 *arg2 = 0 ;
80703
80704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80705   arg2 = (Dali::Vector2 *)jarg2;
80706   if (!arg2) {
80707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80708     return ;
80709   }
80710   {
80711     try {
80712       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80713     } catch (std::out_of_range& e) {
80714       {
80715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80716       };
80717     } catch (std::exception& e) {
80718       {
80719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80720       };
80721     } catch (Dali::DaliException e) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80724       };
80725     } catch (...) {
80726       {
80727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80728       };
80729     }
80730   }
80731
80732 }
80733
80734
80735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80736   float jresult ;
80737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80738   float result;
80739
80740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80741   {
80742     try {
80743       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80744     } catch (std::out_of_range& e) {
80745       {
80746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (std::exception& e) {
80749       {
80750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (Dali::DaliException e) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80755       };
80756     } catch (...) {
80757       {
80758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80759       };
80760     }
80761   }
80762
80763   jresult = result;
80764   return jresult;
80765 }
80766
80767
80768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80770   float arg2 ;
80771
80772   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80773   arg2 = (float)jarg2;
80774   {
80775     try {
80776       (arg1)->SetMinimumSpeedForFlick(arg2);
80777     } catch (std::out_of_range& e) {
80778       {
80779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80780       };
80781     } catch (std::exception& e) {
80782       {
80783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80784       };
80785     } catch (Dali::DaliException e) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80788       };
80789     } catch (...) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80792       };
80793     }
80794   }
80795
80796 }
80797
80798
80799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80800   float jresult ;
80801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80802   float result;
80803
80804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80805   {
80806     try {
80807       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80808     } catch (std::out_of_range& e) {
80809       {
80810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80811       };
80812     } catch (std::exception& e) {
80813       {
80814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80815       };
80816     } catch (Dali::DaliException e) {
80817       {
80818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80819       };
80820     } catch (...) {
80821       {
80822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80823       };
80824     }
80825   }
80826
80827   jresult = result;
80828   return jresult;
80829 }
80830
80831
80832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80833   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80834   float arg2 ;
80835
80836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80837   arg2 = (float)jarg2;
80838   {
80839     try {
80840       (arg1)->SetMaxFlickSpeed(arg2);
80841     } catch (std::out_of_range& e) {
80842       {
80843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80844       };
80845     } catch (std::exception& e) {
80846       {
80847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80848       };
80849     } catch (Dali::DaliException e) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80852       };
80853     } catch (...) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80856       };
80857     }
80858   }
80859
80860 }
80861
80862
80863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80864   void * jresult ;
80865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80866   Dali::Vector2 result;
80867
80868   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80869   {
80870     try {
80871       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80872     } catch (std::out_of_range& e) {
80873       {
80874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80875       };
80876     } catch (std::exception& e) {
80877       {
80878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80879       };
80880     } catch (Dali::DaliException e) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80883       };
80884     } catch (...) {
80885       {
80886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80887       };
80888     }
80889   }
80890
80891   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80892   return jresult;
80893 }
80894
80895
80896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80898   Dali::Vector2 arg2 ;
80899   Dali::Vector2 *argp2 ;
80900
80901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80902   argp2 = (Dali::Vector2 *)jarg2;
80903   if (!argp2) {
80904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80905     return ;
80906   }
80907   arg2 = *argp2;
80908   {
80909     try {
80910       (arg1)->SetWheelScrollDistanceStep(arg2);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80918       };
80919     } catch (Dali::DaliException e) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80922       };
80923     } catch (...) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80926       };
80927     }
80928   }
80929
80930 }
80931
80932
80933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80934   void * jresult ;
80935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80936   Dali::Vector2 result;
80937
80938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80939   {
80940     try {
80941       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (Dali::DaliException e) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80953       };
80954     } catch (...) {
80955       {
80956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80957       };
80958     }
80959   }
80960
80961   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80967   unsigned int jresult ;
80968   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80969   unsigned int result;
80970
80971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80972   {
80973     try {
80974       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (Dali::DaliException e) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80986       };
80987     } catch (...) {
80988       {
80989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80990       };
80991     }
80992   }
80993
80994   jresult = result;
80995   return jresult;
80996 }
80997
80998
80999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81001   Dali::Vector2 *arg2 = 0 ;
81002
81003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81004   arg2 = (Dali::Vector2 *)jarg2;
81005   if (!arg2) {
81006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81007     return ;
81008   }
81009   {
81010     try {
81011       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81012     } catch (std::out_of_range& e) {
81013       {
81014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81015       };
81016     } catch (std::exception& e) {
81017       {
81018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81019       };
81020     } catch (Dali::DaliException e) {
81021       {
81022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81023       };
81024     } catch (...) {
81025       {
81026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81027       };
81028     }
81029   }
81030
81031 }
81032
81033
81034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81035   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81036   Dali::Vector2 *arg2 = 0 ;
81037   float arg3 ;
81038
81039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81040   arg2 = (Dali::Vector2 *)jarg2;
81041   if (!arg2) {
81042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81043     return ;
81044   }
81045   arg3 = (float)jarg3;
81046   {
81047     try {
81048       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81056       };
81057     } catch (Dali::DaliException e) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81060       };
81061     } catch (...) {
81062       {
81063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81064       };
81065     }
81066   }
81067
81068 }
81069
81070
81071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81072   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81073   Dali::Vector2 *arg2 = 0 ;
81074   float arg3 ;
81075   Dali::AlphaFunction arg4 ;
81076   Dali::AlphaFunction *argp4 ;
81077
81078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81079   arg2 = (Dali::Vector2 *)jarg2;
81080   if (!arg2) {
81081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81082     return ;
81083   }
81084   arg3 = (float)jarg3;
81085   argp4 = (Dali::AlphaFunction *)jarg4;
81086   if (!argp4) {
81087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81088     return ;
81089   }
81090   arg4 = *argp4;
81091   {
81092     try {
81093       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81094     } catch (std::out_of_range& e) {
81095       {
81096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81097       };
81098     } catch (std::exception& e) {
81099       {
81100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81101       };
81102     } catch (Dali::DaliException e) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81105       };
81106     } catch (...) {
81107       {
81108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81109       };
81110     }
81111   }
81112
81113 }
81114
81115
81116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81117   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81118   Dali::Vector2 *arg2 = 0 ;
81119   float arg3 ;
81120   Dali::Toolkit::DirectionBias arg4 ;
81121   Dali::Toolkit::DirectionBias arg5 ;
81122
81123   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81124   arg2 = (Dali::Vector2 *)jarg2;
81125   if (!arg2) {
81126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81127     return ;
81128   }
81129   arg3 = (float)jarg3;
81130   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81131   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81132   {
81133     try {
81134       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81135     } catch (std::out_of_range& e) {
81136       {
81137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81138       };
81139     } catch (std::exception& e) {
81140       {
81141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81142       };
81143     } catch (Dali::DaliException e) {
81144       {
81145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81146       };
81147     } catch (...) {
81148       {
81149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81150       };
81151     }
81152   }
81153
81154 }
81155
81156
81157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81159   Dali::Vector2 *arg2 = 0 ;
81160   float arg3 ;
81161   Dali::AlphaFunction arg4 ;
81162   Dali::Toolkit::DirectionBias arg5 ;
81163   Dali::Toolkit::DirectionBias arg6 ;
81164   Dali::AlphaFunction *argp4 ;
81165
81166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81167   arg2 = (Dali::Vector2 *)jarg2;
81168   if (!arg2) {
81169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81170     return ;
81171   }
81172   arg3 = (float)jarg3;
81173   argp4 = (Dali::AlphaFunction *)jarg4;
81174   if (!argp4) {
81175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81176     return ;
81177   }
81178   arg4 = *argp4;
81179   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81180   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81181   {
81182     try {
81183       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81184     } catch (std::out_of_range& e) {
81185       {
81186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81187       };
81188     } catch (std::exception& e) {
81189       {
81190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81191       };
81192     } catch (Dali::DaliException e) {
81193       {
81194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81199       };
81200     }
81201   }
81202
81203 }
81204
81205
81206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81208   unsigned int arg2 ;
81209
81210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81211   arg2 = (unsigned int)jarg2;
81212   {
81213     try {
81214       (arg1)->ScrollTo(arg2);
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (Dali::DaliException e) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81230       };
81231     }
81232   }
81233
81234 }
81235
81236
81237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81239   unsigned int arg2 ;
81240   float arg3 ;
81241
81242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81243   arg2 = (unsigned int)jarg2;
81244   arg3 = (float)jarg3;
81245   {
81246     try {
81247       (arg1)->ScrollTo(arg2,arg3);
81248     } catch (std::out_of_range& e) {
81249       {
81250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81251       };
81252     } catch (std::exception& e) {
81253       {
81254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81255       };
81256     } catch (Dali::DaliException e) {
81257       {
81258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81259       };
81260     } catch (...) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81263       };
81264     }
81265   }
81266
81267 }
81268
81269
81270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81272   unsigned int arg2 ;
81273   float arg3 ;
81274   Dali::Toolkit::DirectionBias arg4 ;
81275
81276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81277   arg2 = (unsigned int)jarg2;
81278   arg3 = (float)jarg3;
81279   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81280   {
81281     try {
81282       (arg1)->ScrollTo(arg2,arg3,arg4);
81283     } catch (std::out_of_range& e) {
81284       {
81285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81286       };
81287     } catch (std::exception& e) {
81288       {
81289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81290       };
81291     } catch (Dali::DaliException e) {
81292       {
81293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81294       };
81295     } catch (...) {
81296       {
81297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81298       };
81299     }
81300   }
81301
81302 }
81303
81304
81305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81307   Dali::Actor *arg2 = 0 ;
81308
81309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81310   arg2 = (Dali::Actor *)jarg2;
81311   if (!arg2) {
81312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81313     return ;
81314   }
81315   {
81316     try {
81317       (arg1)->ScrollTo(*arg2);
81318     } catch (std::out_of_range& e) {
81319       {
81320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81321       };
81322     } catch (std::exception& e) {
81323       {
81324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81325       };
81326     } catch (Dali::DaliException e) {
81327       {
81328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81329       };
81330     } catch (...) {
81331       {
81332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81333       };
81334     }
81335   }
81336
81337 }
81338
81339
81340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81342   Dali::Actor *arg2 = 0 ;
81343   float arg3 ;
81344
81345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81346   arg2 = (Dali::Actor *)jarg2;
81347   if (!arg2) {
81348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81349     return ;
81350   }
81351   arg3 = (float)jarg3;
81352   {
81353     try {
81354       (arg1)->ScrollTo(*arg2,arg3);
81355     } catch (std::out_of_range& e) {
81356       {
81357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81358       };
81359     } catch (std::exception& e) {
81360       {
81361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81362       };
81363     } catch (Dali::DaliException e) {
81364       {
81365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81370       };
81371     }
81372   }
81373
81374 }
81375
81376
81377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81378   unsigned int jresult ;
81379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81380   bool result;
81381
81382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81383   {
81384     try {
81385       result = (bool)(arg1)->ScrollToSnapPoint();
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (Dali::DaliException e) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81397       };
81398     } catch (...) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81401       };
81402     }
81403   }
81404
81405   jresult = result;
81406   return jresult;
81407 }
81408
81409
81410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81412   Dali::Constraint arg2 ;
81413   Dali::Constraint *argp2 ;
81414
81415   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81416   argp2 = (Dali::Constraint *)jarg2;
81417   if (!argp2) {
81418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81419     return ;
81420   }
81421   arg2 = *argp2;
81422   {
81423     try {
81424       (arg1)->ApplyConstraintToChildren(arg2);
81425     } catch (std::out_of_range& e) {
81426       {
81427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81428       };
81429     } catch (std::exception& e) {
81430       {
81431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81432       };
81433     } catch (Dali::DaliException e) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81436       };
81437     } catch (...) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81440       };
81441     }
81442   }
81443
81444 }
81445
81446
81447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81448   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81449
81450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81451   {
81452     try {
81453       (arg1)->RemoveConstraintsFromChildren();
81454     } catch (std::out_of_range& e) {
81455       {
81456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81457       };
81458     } catch (std::exception& e) {
81459       {
81460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81461       };
81462     } catch (Dali::DaliException e) {
81463       {
81464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81465       };
81466     } catch (...) {
81467       {
81468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81469       };
81470     }
81471   }
81472
81473 }
81474
81475
81476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81478   Dali::Toolkit::ScrollViewEffect arg2 ;
81479   Dali::Toolkit::ScrollViewEffect *argp2 ;
81480
81481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81482   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81483   if (!argp2) {
81484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81485     return ;
81486   }
81487   arg2 = *argp2;
81488   {
81489     try {
81490       (arg1)->ApplyEffect(arg2);
81491     } catch (std::out_of_range& e) {
81492       {
81493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81494       };
81495     } catch (std::exception& e) {
81496       {
81497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81498       };
81499     } catch (Dali::DaliException e) {
81500       {
81501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81502       };
81503     } catch (...) {
81504       {
81505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81506       };
81507     }
81508   }
81509
81510 }
81511
81512
81513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81515   Dali::Toolkit::ScrollViewEffect arg2 ;
81516   Dali::Toolkit::ScrollViewEffect *argp2 ;
81517
81518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81519   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81520   if (!argp2) {
81521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81522     return ;
81523   }
81524   arg2 = *argp2;
81525   {
81526     try {
81527       (arg1)->RemoveEffect(arg2);
81528     } catch (std::out_of_range& e) {
81529       {
81530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81531       };
81532     } catch (std::exception& e) {
81533       {
81534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81535       };
81536     } catch (Dali::DaliException e) {
81537       {
81538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81539       };
81540     } catch (...) {
81541       {
81542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81543       };
81544     }
81545   }
81546
81547 }
81548
81549
81550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81552
81553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81554   {
81555     try {
81556       (arg1)->RemoveAllEffects();
81557     } catch (std::out_of_range& e) {
81558       {
81559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81560       };
81561     } catch (std::exception& e) {
81562       {
81563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81564       };
81565     } catch (Dali::DaliException e) {
81566       {
81567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81568       };
81569     } catch (...) {
81570       {
81571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81572       };
81573     }
81574   }
81575
81576 }
81577
81578
81579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81581   Dali::Actor arg2 ;
81582   Dali::Actor *argp2 ;
81583
81584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81585   argp2 = (Dali::Actor *)jarg2;
81586   if (!argp2) {
81587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81588     return ;
81589   }
81590   arg2 = *argp2;
81591   {
81592     try {
81593       (arg1)->BindActor(arg2);
81594     } catch (std::out_of_range& e) {
81595       {
81596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81597       };
81598     } catch (std::exception& e) {
81599       {
81600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81601       };
81602     } catch (Dali::DaliException e) {
81603       {
81604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81605       };
81606     } catch (...) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81609       };
81610     }
81611   }
81612
81613 }
81614
81615
81616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81618   Dali::Actor arg2 ;
81619   Dali::Actor *argp2 ;
81620
81621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81622   argp2 = (Dali::Actor *)jarg2;
81623   if (!argp2) {
81624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81625     return ;
81626   }
81627   arg2 = *argp2;
81628   {
81629     try {
81630       (arg1)->UnbindActor(arg2);
81631     } catch (std::out_of_range& e) {
81632       {
81633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81634       };
81635     } catch (std::exception& e) {
81636       {
81637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81638       };
81639     } catch (Dali::DaliException e) {
81640       {
81641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81642       };
81643     } catch (...) {
81644       {
81645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81646       };
81647     }
81648   }
81649
81650 }
81651
81652
81653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81655   Dali::Radian arg2 ;
81656   Dali::Radian arg3 ;
81657   Dali::Radian *argp2 ;
81658   Dali::Radian *argp3 ;
81659
81660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81661   argp2 = (Dali::Radian *)jarg2;
81662   if (!argp2) {
81663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81664     return ;
81665   }
81666   arg2 = *argp2;
81667   argp3 = (Dali::Radian *)jarg3;
81668   if (!argp3) {
81669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81670     return ;
81671   }
81672   arg3 = *argp3;
81673   {
81674     try {
81675       (arg1)->SetScrollingDirection(arg2,arg3);
81676     } catch (std::out_of_range& e) {
81677       {
81678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81679       };
81680     } catch (std::exception& e) {
81681       {
81682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81683       };
81684     } catch (Dali::DaliException e) {
81685       {
81686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81687       };
81688     } catch (...) {
81689       {
81690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81691       };
81692     }
81693   }
81694
81695 }
81696
81697
81698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81700   Dali::Radian arg2 ;
81701   Dali::Radian *argp2 ;
81702
81703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81704   argp2 = (Dali::Radian *)jarg2;
81705   if (!argp2) {
81706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81707     return ;
81708   }
81709   arg2 = *argp2;
81710   {
81711     try {
81712       (arg1)->SetScrollingDirection(arg2);
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (Dali::DaliException e) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81724       };
81725     } catch (...) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81728       };
81729     }
81730   }
81731
81732 }
81733
81734
81735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737   Dali::Radian arg2 ;
81738   Dali::Radian *argp2 ;
81739
81740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81741   argp2 = (Dali::Radian *)jarg2;
81742   if (!argp2) {
81743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81744     return ;
81745   }
81746   arg2 = *argp2;
81747   {
81748     try {
81749       (arg1)->RemoveScrollingDirection(arg2);
81750     } catch (std::out_of_range& e) {
81751       {
81752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81753       };
81754     } catch (std::exception& e) {
81755       {
81756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81757       };
81758     } catch (Dali::DaliException e) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81761       };
81762     } catch (...) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81765       };
81766     }
81767   }
81768
81769 }
81770
81771
81772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81773   void * jresult ;
81774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81775   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81776
81777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81778   {
81779     try {
81780       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81781     } catch (std::out_of_range& e) {
81782       {
81783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81784       };
81785     } catch (std::exception& e) {
81786       {
81787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (Dali::DaliException e) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81792       };
81793     } catch (...) {
81794       {
81795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81796       };
81797     }
81798   }
81799
81800   jresult = (void *)result;
81801   return jresult;
81802 }
81803
81804
81805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81806   int jresult ;
81807   int result;
81808
81809   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81810   jresult = (int)result;
81811   return jresult;
81812 }
81813
81814
81815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81816   int jresult ;
81817   int result;
81818
81819   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81820   jresult = (int)result;
81821   return jresult;
81822 }
81823
81824
81825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81826   int jresult ;
81827   int result;
81828
81829   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81830   jresult = (int)result;
81831   return jresult;
81832 }
81833
81834
81835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81836   int jresult ;
81837   int result;
81838
81839   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81840   jresult = (int)result;
81841   return jresult;
81842 }
81843
81844
81845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81846   int jresult ;
81847   int result;
81848
81849   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81850   jresult = (int)result;
81851   return jresult;
81852 }
81853
81854
81855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81856   void * jresult ;
81857   Dali::Toolkit::TableView::Property *result = 0 ;
81858
81859   {
81860     try {
81861       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81862     } catch (std::out_of_range& e) {
81863       {
81864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81865       };
81866     } catch (std::exception& e) {
81867       {
81868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81869       };
81870     } catch (Dali::DaliException e) {
81871       {
81872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81873       };
81874     } catch (...) {
81875       {
81876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81877       };
81878     }
81879   }
81880
81881   jresult = (void *)result;
81882   return jresult;
81883 }
81884
81885
81886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81887   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81888
81889   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81890   {
81891     try {
81892       delete arg1;
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81900       };
81901     } catch (Dali::DaliException e) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81904       };
81905     } catch (...) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81908       };
81909     }
81910   }
81911
81912 }
81913
81914
81915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81916   int jresult ;
81917   int result;
81918
81919   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81920   jresult = (int)result;
81921   return jresult;
81922 }
81923
81924
81925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81926   int jresult ;
81927   int result;
81928
81929   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81930   jresult = (int)result;
81931   return jresult;
81932 }
81933
81934
81935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81936   int jresult ;
81937   int result;
81938
81939   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81940   jresult = (int)result;
81941   return jresult;
81942 }
81943
81944
81945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81946   int jresult ;
81947   int result;
81948
81949   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81950   jresult = (int)result;
81951   return jresult;
81952 }
81953
81954
81955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81956   int jresult ;
81957   int result;
81958
81959   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81960   jresult = (int)result;
81961   return jresult;
81962 }
81963
81964
81965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81966   void * jresult ;
81967   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81968
81969   {
81970     try {
81971       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81972     } catch (std::out_of_range& e) {
81973       {
81974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81975       };
81976     } catch (std::exception& e) {
81977       {
81978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81979       };
81980     } catch (Dali::DaliException e) {
81981       {
81982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81983       };
81984     } catch (...) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81987       };
81988     }
81989   }
81990
81991   jresult = (void *)result;
81992   return jresult;
81993 }
81994
81995
81996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81997   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81998
81999   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82000   {
82001     try {
82002       delete arg1;
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (Dali::DaliException e) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82014       };
82015     } catch (...) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82018       };
82019     }
82020   }
82021
82022 }
82023
82024
82025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82026   void * jresult ;
82027   unsigned int arg1 ;
82028   unsigned int arg2 ;
82029   unsigned int arg3 ;
82030   unsigned int arg4 ;
82031   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82032
82033   arg1 = (unsigned int)jarg1;
82034   arg2 = (unsigned int)jarg2;
82035   arg3 = (unsigned int)jarg3;
82036   arg4 = (unsigned int)jarg4;
82037   {
82038     try {
82039       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82040     } catch (std::out_of_range& e) {
82041       {
82042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82043       };
82044     } catch (std::exception& e) {
82045       {
82046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82047       };
82048     } catch (Dali::DaliException e) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82051       };
82052     } catch (...) {
82053       {
82054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82055       };
82056     }
82057   }
82058
82059   jresult = (void *)result;
82060   return jresult;
82061 }
82062
82063
82064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82065   void * jresult ;
82066   unsigned int arg1 ;
82067   unsigned int arg2 ;
82068   unsigned int arg3 ;
82069   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82070
82071   arg1 = (unsigned int)jarg1;
82072   arg2 = (unsigned int)jarg2;
82073   arg3 = (unsigned int)jarg3;
82074   {
82075     try {
82076       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82077     } catch (std::out_of_range& e) {
82078       {
82079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (std::exception& e) {
82082       {
82083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82084       };
82085     } catch (Dali::DaliException e) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82088       };
82089     } catch (...) {
82090       {
82091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82092       };
82093     }
82094   }
82095
82096   jresult = (void *)result;
82097   return jresult;
82098 }
82099
82100
82101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82102   void * jresult ;
82103   unsigned int arg1 ;
82104   unsigned int arg2 ;
82105   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82106
82107   arg1 = (unsigned int)jarg1;
82108   arg2 = (unsigned int)jarg2;
82109   {
82110     try {
82111       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82112     } catch (std::out_of_range& e) {
82113       {
82114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82115       };
82116     } catch (std::exception& e) {
82117       {
82118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82119       };
82120     } catch (Dali::DaliException e) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82123       };
82124     } catch (...) {
82125       {
82126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82127       };
82128     }
82129   }
82130
82131   jresult = (void *)result;
82132   return jresult;
82133 }
82134
82135
82136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82137   void * jresult ;
82138   unsigned int arg1 ;
82139   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82140
82141   arg1 = (unsigned int)jarg1;
82142   {
82143     try {
82144       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82145     } catch (std::out_of_range& e) {
82146       {
82147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82148       };
82149     } catch (std::exception& e) {
82150       {
82151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (Dali::DaliException e) {
82154       {
82155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82160       };
82161     }
82162   }
82163
82164   jresult = (void *)result;
82165   return jresult;
82166 }
82167
82168
82169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82170   void * jresult ;
82171   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82172
82173   {
82174     try {
82175       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82176     } catch (std::out_of_range& e) {
82177       {
82178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82179       };
82180     } catch (std::exception& e) {
82181       {
82182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82183       };
82184     } catch (Dali::DaliException e) {
82185       {
82186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82187       };
82188     } catch (...) {
82189       {
82190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82191       };
82192     }
82193   }
82194
82195   jresult = (void *)result;
82196   return jresult;
82197 }
82198
82199
82200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82201   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82202   unsigned int arg2 ;
82203
82204   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82205   arg2 = (unsigned int)jarg2;
82206   if (arg1) (arg1)->rowIndex = arg2;
82207 }
82208
82209
82210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82211   unsigned int jresult ;
82212   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82213   unsigned int result;
82214
82215   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82216   result = (unsigned int) ((arg1)->rowIndex);
82217   jresult = result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82223   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82224   unsigned int arg2 ;
82225
82226   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82227   arg2 = (unsigned int)jarg2;
82228   if (arg1) (arg1)->columnIndex = arg2;
82229 }
82230
82231
82232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82233   unsigned int jresult ;
82234   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82235   unsigned int result;
82236
82237   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82238   result = (unsigned int) ((arg1)->columnIndex);
82239   jresult = result;
82240   return jresult;
82241 }
82242
82243
82244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82245   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82246   unsigned int arg2 ;
82247
82248   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82249   arg2 = (unsigned int)jarg2;
82250   if (arg1) (arg1)->rowSpan = arg2;
82251 }
82252
82253
82254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82255   unsigned int jresult ;
82256   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82257   unsigned int result;
82258
82259   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82260   result = (unsigned int) ((arg1)->rowSpan);
82261   jresult = result;
82262   return jresult;
82263 }
82264
82265
82266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82267   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82268   unsigned int arg2 ;
82269
82270   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82271   arg2 = (unsigned int)jarg2;
82272   if (arg1) (arg1)->columnSpan = arg2;
82273 }
82274
82275
82276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82277   unsigned int jresult ;
82278   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82279   unsigned int result;
82280
82281   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82282   result = (unsigned int) ((arg1)->columnSpan);
82283   jresult = result;
82284   return jresult;
82285 }
82286
82287
82288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82289   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82290
82291   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82292   {
82293     try {
82294       delete arg1;
82295     } catch (std::out_of_range& e) {
82296       {
82297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (std::exception& e) {
82300       {
82301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (Dali::DaliException e) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313
82314 }
82315
82316
82317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82318   void * jresult ;
82319   Dali::Toolkit::TableView *result = 0 ;
82320
82321   {
82322     try {
82323       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82324     } catch (std::out_of_range& e) {
82325       {
82326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82327       };
82328     } catch (std::exception& e) {
82329       {
82330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (Dali::DaliException e) {
82333       {
82334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82335       };
82336     } catch (...) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82339       };
82340     }
82341   }
82342
82343   jresult = (void *)result;
82344   return jresult;
82345 }
82346
82347
82348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82349   void * jresult ;
82350   Dali::Toolkit::TableView *arg1 = 0 ;
82351   Dali::Toolkit::TableView *result = 0 ;
82352
82353   arg1 = (Dali::Toolkit::TableView *)jarg1;
82354   if (!arg1) {
82355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82356     return 0;
82357   }
82358   {
82359     try {
82360       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82376       };
82377     }
82378   }
82379
82380   jresult = (void *)result;
82381   return jresult;
82382 }
82383
82384
82385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82386   void * jresult ;
82387   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82388   Dali::Toolkit::TableView *arg2 = 0 ;
82389   Dali::Toolkit::TableView *result = 0 ;
82390
82391   arg1 = (Dali::Toolkit::TableView *)jarg1;
82392   arg2 = (Dali::Toolkit::TableView *)jarg2;
82393   if (!arg2) {
82394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82395     return 0;
82396   }
82397   {
82398     try {
82399       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (Dali::DaliException e) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418
82419   jresult = (void *)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82426
82427   arg1 = (Dali::Toolkit::TableView *)jarg1;
82428   {
82429     try {
82430       delete arg1;
82431     } catch (std::out_of_range& e) {
82432       {
82433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82434       };
82435     } catch (std::exception& e) {
82436       {
82437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82438       };
82439     } catch (Dali::DaliException e) {
82440       {
82441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82442       };
82443     } catch (...) {
82444       {
82445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82446       };
82447     }
82448   }
82449
82450 }
82451
82452
82453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82454   void * jresult ;
82455   unsigned int arg1 ;
82456   unsigned int arg2 ;
82457   Dali::Toolkit::TableView result;
82458
82459   arg1 = (unsigned int)jarg1;
82460   arg2 = (unsigned int)jarg2;
82461   {
82462     try {
82463       result = Dali::Toolkit::TableView::New(arg1,arg2);
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (Dali::DaliException e) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82475       };
82476     } catch (...) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82479       };
82480     }
82481   }
82482
82483   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82489   void * jresult ;
82490   Dali::BaseHandle arg1 ;
82491   Dali::BaseHandle *argp1 ;
82492   Dali::Toolkit::TableView result;
82493
82494   argp1 = (Dali::BaseHandle *)jarg1;
82495   if (!argp1) {
82496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82497     return 0;
82498   }
82499   arg1 = *argp1;
82500   {
82501     try {
82502       result = Dali::Toolkit::TableView::DownCast(arg1);
82503     } catch (std::out_of_range& e) {
82504       {
82505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82506       };
82507     } catch (std::exception& e) {
82508       {
82509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82510       };
82511     } catch (Dali::DaliException e) {
82512       {
82513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82514       };
82515     } catch (...) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82518       };
82519     }
82520   }
82521
82522   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82523   return jresult;
82524 }
82525
82526
82527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82528   unsigned int jresult ;
82529   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82530   Dali::Actor arg2 ;
82531   Dali::Toolkit::TableView::CellPosition arg3 ;
82532   Dali::Actor *argp2 ;
82533   Dali::Toolkit::TableView::CellPosition *argp3 ;
82534   bool result;
82535
82536   arg1 = (Dali::Toolkit::TableView *)jarg1;
82537   argp2 = (Dali::Actor *)jarg2;
82538   if (!argp2) {
82539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82540     return 0;
82541   }
82542   arg2 = *argp2;
82543   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82544   if (!argp3) {
82545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82546     return 0;
82547   }
82548   arg3 = *argp3;
82549   {
82550     try {
82551       result = (bool)(arg1)->AddChild(arg2,arg3);
82552     } catch (std::out_of_range& e) {
82553       {
82554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82555       };
82556     } catch (std::exception& e) {
82557       {
82558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82559       };
82560     } catch (Dali::DaliException e) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82563       };
82564     } catch (...) {
82565       {
82566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82567       };
82568     }
82569   }
82570
82571   jresult = result;
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82577   void * jresult ;
82578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82579   Dali::Toolkit::TableView::CellPosition arg2 ;
82580   Dali::Toolkit::TableView::CellPosition *argp2 ;
82581   Dali::Actor result;
82582
82583   arg1 = (Dali::Toolkit::TableView *)jarg1;
82584   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82585   if (!argp2) {
82586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82587     return 0;
82588   }
82589   arg2 = *argp2;
82590   {
82591     try {
82592       result = (arg1)->GetChildAt(arg2);
82593     } catch (std::out_of_range& e) {
82594       {
82595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82596       };
82597     } catch (std::exception& e) {
82598       {
82599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82600       };
82601     } catch (Dali::DaliException e) {
82602       {
82603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82604       };
82605     } catch (...) {
82606       {
82607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82608       };
82609     }
82610   }
82611
82612   jresult = new Dali::Actor((const Dali::Actor &)result);
82613   return jresult;
82614 }
82615
82616
82617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82618   void * jresult ;
82619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82620   Dali::Toolkit::TableView::CellPosition arg2 ;
82621   Dali::Toolkit::TableView::CellPosition *argp2 ;
82622   Dali::Actor result;
82623
82624   arg1 = (Dali::Toolkit::TableView *)jarg1;
82625   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82626   if (!argp2) {
82627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82628     return 0;
82629   }
82630   arg2 = *argp2;
82631   {
82632     try {
82633       result = (arg1)->RemoveChildAt(arg2);
82634     } catch (std::out_of_range& e) {
82635       {
82636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82637       };
82638     } catch (std::exception& e) {
82639       {
82640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82641       };
82642     } catch (Dali::DaliException e) {
82643       {
82644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82645       };
82646     } catch (...) {
82647       {
82648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82649       };
82650     }
82651   }
82652
82653   jresult = new Dali::Actor((const Dali::Actor &)result);
82654   return jresult;
82655 }
82656
82657
82658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82659   unsigned int jresult ;
82660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82661   Dali::Actor arg2 ;
82662   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82663   Dali::Actor *argp2 ;
82664   bool result;
82665
82666   arg1 = (Dali::Toolkit::TableView *)jarg1;
82667   argp2 = (Dali::Actor *)jarg2;
82668   if (!argp2) {
82669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82670     return 0;
82671   }
82672   arg2 = *argp2;
82673   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82674   if (!arg3) {
82675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82676     return 0;
82677   }
82678   {
82679     try {
82680       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82681     } catch (std::out_of_range& e) {
82682       {
82683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82684       };
82685     } catch (std::exception& e) {
82686       {
82687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (Dali::DaliException e) {
82690       {
82691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82692       };
82693     } catch (...) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82696       };
82697     }
82698   }
82699
82700   jresult = result;
82701   return jresult;
82702 }
82703
82704
82705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82706   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82707   unsigned int arg2 ;
82708
82709   arg1 = (Dali::Toolkit::TableView *)jarg1;
82710   arg2 = (unsigned int)jarg2;
82711   {
82712     try {
82713       (arg1)->InsertRow(arg2);
82714     } catch (std::out_of_range& e) {
82715       {
82716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82717       };
82718     } catch (std::exception& e) {
82719       {
82720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82721       };
82722     } catch (Dali::DaliException e) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82725       };
82726     } catch (...) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82729       };
82730     }
82731   }
82732
82733 }
82734
82735
82736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82737   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82738   unsigned int arg2 ;
82739
82740   arg1 = (Dali::Toolkit::TableView *)jarg1;
82741   arg2 = (unsigned int)jarg2;
82742   {
82743     try {
82744       (arg1)->DeleteRow(arg2);
82745     } catch (std::out_of_range& e) {
82746       {
82747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82748       };
82749     } catch (std::exception& e) {
82750       {
82751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82752       };
82753     } catch (Dali::DaliException e) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82756       };
82757     } catch (...) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82760       };
82761     }
82762   }
82763
82764 }
82765
82766
82767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82768   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82769   unsigned int arg2 ;
82770   std::vector< Dali::Actor > *arg3 = 0 ;
82771
82772   arg1 = (Dali::Toolkit::TableView *)jarg1;
82773   arg2 = (unsigned int)jarg2;
82774   arg3 = (std::vector< Dali::Actor > *)jarg3;
82775   if (!arg3) {
82776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82777     return ;
82778   }
82779   {
82780     try {
82781       (arg1)->DeleteRow(arg2,*arg3);
82782     } catch (std::out_of_range& e) {
82783       {
82784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82785       };
82786     } catch (std::exception& e) {
82787       {
82788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82789       };
82790     } catch (Dali::DaliException e) {
82791       {
82792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82793       };
82794     } catch (...) {
82795       {
82796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82797       };
82798     }
82799   }
82800
82801 }
82802
82803
82804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82805   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82806   unsigned int arg2 ;
82807
82808   arg1 = (Dali::Toolkit::TableView *)jarg1;
82809   arg2 = (unsigned int)jarg2;
82810   {
82811     try {
82812       (arg1)->InsertColumn(arg2);
82813     } catch (std::out_of_range& e) {
82814       {
82815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82816       };
82817     } catch (std::exception& e) {
82818       {
82819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82820       };
82821     } catch (Dali::DaliException e) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82828       };
82829     }
82830   }
82831
82832 }
82833
82834
82835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82836   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82837   unsigned int arg2 ;
82838
82839   arg1 = (Dali::Toolkit::TableView *)jarg1;
82840   arg2 = (unsigned int)jarg2;
82841   {
82842     try {
82843       (arg1)->DeleteColumn(arg2);
82844     } catch (std::out_of_range& e) {
82845       {
82846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82847       };
82848     } catch (std::exception& e) {
82849       {
82850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82851       };
82852     } catch (Dali::DaliException e) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82855       };
82856     } catch (...) {
82857       {
82858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82859       };
82860     }
82861   }
82862
82863 }
82864
82865
82866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82867   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82868   unsigned int arg2 ;
82869   std::vector< Dali::Actor > *arg3 = 0 ;
82870
82871   arg1 = (Dali::Toolkit::TableView *)jarg1;
82872   arg2 = (unsigned int)jarg2;
82873   arg3 = (std::vector< Dali::Actor > *)jarg3;
82874   if (!arg3) {
82875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82876     return ;
82877   }
82878   {
82879     try {
82880       (arg1)->DeleteColumn(arg2,*arg3);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82888       };
82889     } catch (Dali::DaliException e) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82892       };
82893     } catch (...) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82896       };
82897     }
82898   }
82899
82900 }
82901
82902
82903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82905   unsigned int arg2 ;
82906   unsigned int arg3 ;
82907
82908   arg1 = (Dali::Toolkit::TableView *)jarg1;
82909   arg2 = (unsigned int)jarg2;
82910   arg3 = (unsigned int)jarg3;
82911   {
82912     try {
82913       (arg1)->Resize(arg2,arg3);
82914     } catch (std::out_of_range& e) {
82915       {
82916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82917       };
82918     } catch (std::exception& e) {
82919       {
82920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82921       };
82922     } catch (Dali::DaliException e) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82925       };
82926     } catch (...) {
82927       {
82928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82929       };
82930     }
82931   }
82932
82933 }
82934
82935
82936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82938   unsigned int arg2 ;
82939   unsigned int arg3 ;
82940   std::vector< Dali::Actor > *arg4 = 0 ;
82941
82942   arg1 = (Dali::Toolkit::TableView *)jarg1;
82943   arg2 = (unsigned int)jarg2;
82944   arg3 = (unsigned int)jarg3;
82945   arg4 = (std::vector< Dali::Actor > *)jarg4;
82946   if (!arg4) {
82947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82948     return ;
82949   }
82950   {
82951     try {
82952       (arg1)->Resize(arg2,arg3,*arg4);
82953     } catch (std::out_of_range& e) {
82954       {
82955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82956       };
82957     } catch (std::exception& e) {
82958       {
82959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82960       };
82961     } catch (Dali::DaliException e) {
82962       {
82963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82964       };
82965     } catch (...) {
82966       {
82967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82968       };
82969     }
82970   }
82971
82972 }
82973
82974
82975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82976   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82977   Dali::Size arg2 ;
82978   Dali::Size *argp2 ;
82979
82980   arg1 = (Dali::Toolkit::TableView *)jarg1;
82981   argp2 = (Dali::Size *)jarg2;
82982   if (!argp2) {
82983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82984     return ;
82985   }
82986   arg2 = *argp2;
82987   {
82988     try {
82989       (arg1)->SetCellPadding(arg2);
82990     } catch (std::out_of_range& e) {
82991       {
82992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82993       };
82994     } catch (std::exception& e) {
82995       {
82996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82997       };
82998     } catch (Dali::DaliException e) {
82999       {
83000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83001       };
83002     } catch (...) {
83003       {
83004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83005       };
83006     }
83007   }
83008
83009 }
83010
83011
83012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83013   void * jresult ;
83014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83015   Dali::Size result;
83016
83017   arg1 = (Dali::Toolkit::TableView *)jarg1;
83018   {
83019     try {
83020       result = (arg1)->GetCellPadding();
83021     } catch (std::out_of_range& e) {
83022       {
83023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83024       };
83025     } catch (std::exception& e) {
83026       {
83027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83028       };
83029     } catch (Dali::DaliException e) {
83030       {
83031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83032       };
83033     } catch (...) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83036       };
83037     }
83038   }
83039
83040   jresult = new Dali::Size((const Dali::Size &)result);
83041   return jresult;
83042 }
83043
83044
83045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83046   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83047   unsigned int arg2 ;
83048
83049   arg1 = (Dali::Toolkit::TableView *)jarg1;
83050   arg2 = (unsigned int)jarg2;
83051   {
83052     try {
83053       (arg1)->SetFitHeight(arg2);
83054     } catch (std::out_of_range& e) {
83055       {
83056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83057       };
83058     } catch (std::exception& e) {
83059       {
83060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83061       };
83062     } catch (Dali::DaliException e) {
83063       {
83064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83065       };
83066     } catch (...) {
83067       {
83068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83069       };
83070     }
83071   }
83072
83073 }
83074
83075
83076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83077   unsigned int jresult ;
83078   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83079   unsigned int arg2 ;
83080   bool result;
83081
83082   arg1 = (Dali::Toolkit::TableView *)jarg1;
83083   arg2 = (unsigned int)jarg2;
83084   {
83085     try {
83086       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (Dali::DaliException e) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83098       };
83099     } catch (...) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83102       };
83103     }
83104   }
83105
83106   jresult = result;
83107   return jresult;
83108 }
83109
83110
83111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83112   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83113   unsigned int arg2 ;
83114
83115   arg1 = (Dali::Toolkit::TableView *)jarg1;
83116   arg2 = (unsigned int)jarg2;
83117   {
83118     try {
83119       (arg1)->SetFitWidth(arg2);
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83127       };
83128     } catch (Dali::DaliException e) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83131       };
83132     } catch (...) {
83133       {
83134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83135       };
83136     }
83137   }
83138
83139 }
83140
83141
83142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83143   unsigned int jresult ;
83144   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83145   unsigned int arg2 ;
83146   bool result;
83147
83148   arg1 = (Dali::Toolkit::TableView *)jarg1;
83149   arg2 = (unsigned int)jarg2;
83150   {
83151     try {
83152       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (Dali::DaliException e) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83168       };
83169     }
83170   }
83171
83172   jresult = result;
83173   return jresult;
83174 }
83175
83176
83177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83178   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83179   unsigned int arg2 ;
83180   float arg3 ;
83181
83182   arg1 = (Dali::Toolkit::TableView *)jarg1;
83183   arg2 = (unsigned int)jarg2;
83184   arg3 = (float)jarg3;
83185   {
83186     try {
83187       (arg1)->SetFixedHeight(arg2,arg3);
83188     } catch (std::out_of_range& e) {
83189       {
83190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83191       };
83192     } catch (std::exception& e) {
83193       {
83194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83195       };
83196     } catch (Dali::DaliException e) {
83197       {
83198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83199       };
83200     } catch (...) {
83201       {
83202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83203       };
83204     }
83205   }
83206
83207 }
83208
83209
83210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83211   float jresult ;
83212   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83213   unsigned int arg2 ;
83214   float result;
83215
83216   arg1 = (Dali::Toolkit::TableView *)jarg1;
83217   arg2 = (unsigned int)jarg2;
83218   {
83219     try {
83220       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83221     } catch (std::out_of_range& e) {
83222       {
83223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83224       };
83225     } catch (std::exception& e) {
83226       {
83227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (Dali::DaliException e) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83232       };
83233     } catch (...) {
83234       {
83235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83236       };
83237     }
83238   }
83239
83240   jresult = result;
83241   return jresult;
83242 }
83243
83244
83245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83246   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83247   unsigned int arg2 ;
83248   float arg3 ;
83249
83250   arg1 = (Dali::Toolkit::TableView *)jarg1;
83251   arg2 = (unsigned int)jarg2;
83252   arg3 = (float)jarg3;
83253   {
83254     try {
83255       (arg1)->SetRelativeHeight(arg2,arg3);
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83263       };
83264     } catch (Dali::DaliException e) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83267       };
83268     } catch (...) {
83269       {
83270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83271       };
83272     }
83273   }
83274
83275 }
83276
83277
83278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83279   float jresult ;
83280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83281   unsigned int arg2 ;
83282   float result;
83283
83284   arg1 = (Dali::Toolkit::TableView *)jarg1;
83285   arg2 = (unsigned int)jarg2;
83286   {
83287     try {
83288       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83289     } catch (std::out_of_range& e) {
83290       {
83291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83292       };
83293     } catch (std::exception& e) {
83294       {
83295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83296       };
83297     } catch (Dali::DaliException e) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83300       };
83301     } catch (...) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83304       };
83305     }
83306   }
83307
83308   jresult = result;
83309   return jresult;
83310 }
83311
83312
83313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83315   unsigned int arg2 ;
83316   float arg3 ;
83317
83318   arg1 = (Dali::Toolkit::TableView *)jarg1;
83319   arg2 = (unsigned int)jarg2;
83320   arg3 = (float)jarg3;
83321   {
83322     try {
83323       (arg1)->SetFixedWidth(arg2,arg3);
83324     } catch (std::out_of_range& e) {
83325       {
83326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83327       };
83328     } catch (std::exception& e) {
83329       {
83330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83331       };
83332     } catch (Dali::DaliException e) {
83333       {
83334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83335       };
83336     } catch (...) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83339       };
83340     }
83341   }
83342
83343 }
83344
83345
83346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83347   float jresult ;
83348   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83349   unsigned int arg2 ;
83350   float result;
83351
83352   arg1 = (Dali::Toolkit::TableView *)jarg1;
83353   arg2 = (unsigned int)jarg2;
83354   {
83355     try {
83356       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83357     } catch (std::out_of_range& e) {
83358       {
83359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83360       };
83361     } catch (std::exception& e) {
83362       {
83363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (Dali::DaliException e) {
83366       {
83367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83368       };
83369     } catch (...) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83372       };
83373     }
83374   }
83375
83376   jresult = result;
83377   return jresult;
83378 }
83379
83380
83381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83382   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83383   unsigned int arg2 ;
83384   float arg3 ;
83385
83386   arg1 = (Dali::Toolkit::TableView *)jarg1;
83387   arg2 = (unsigned int)jarg2;
83388   arg3 = (float)jarg3;
83389   {
83390     try {
83391       (arg1)->SetRelativeWidth(arg2,arg3);
83392     } catch (std::out_of_range& e) {
83393       {
83394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83395       };
83396     } catch (std::exception& e) {
83397       {
83398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83399       };
83400     } catch (Dali::DaliException e) {
83401       {
83402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83403       };
83404     } catch (...) {
83405       {
83406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83407       };
83408     }
83409   }
83410
83411 }
83412
83413
83414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83415   float jresult ;
83416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83417   unsigned int arg2 ;
83418   float result;
83419
83420   arg1 = (Dali::Toolkit::TableView *)jarg1;
83421   arg2 = (unsigned int)jarg2;
83422   {
83423     try {
83424       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83425     } catch (std::out_of_range& e) {
83426       {
83427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83428       };
83429     } catch (std::exception& e) {
83430       {
83431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83432       };
83433     } catch (Dali::DaliException e) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83436       };
83437     } catch (...) {
83438       {
83439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83440       };
83441     }
83442   }
83443
83444   jresult = result;
83445   return jresult;
83446 }
83447
83448
83449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83450   unsigned int jresult ;
83451   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83452   unsigned int result;
83453
83454   arg1 = (Dali::Toolkit::TableView *)jarg1;
83455   {
83456     try {
83457       result = (unsigned int)(arg1)->GetRows();
83458     } catch (std::out_of_range& e) {
83459       {
83460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83461       };
83462     } catch (std::exception& e) {
83463       {
83464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83465       };
83466     } catch (Dali::DaliException e) {
83467       {
83468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83469       };
83470     } catch (...) {
83471       {
83472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83473       };
83474     }
83475   }
83476
83477   jresult = result;
83478   return jresult;
83479 }
83480
83481
83482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83483   unsigned int jresult ;
83484   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83485   unsigned int result;
83486
83487   arg1 = (Dali::Toolkit::TableView *)jarg1;
83488   {
83489     try {
83490       result = (unsigned int)(arg1)->GetColumns();
83491     } catch (std::out_of_range& e) {
83492       {
83493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (std::exception& e) {
83496       {
83497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83498       };
83499     } catch (Dali::DaliException e) {
83500       {
83501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83502       };
83503     } catch (...) {
83504       {
83505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83506       };
83507     }
83508   }
83509
83510   jresult = result;
83511   return jresult;
83512 }
83513
83514
83515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83516   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83517   Dali::Toolkit::TableView::CellPosition arg2 ;
83518   Dali::HorizontalAlignment::Type arg3 ;
83519   Dali::VerticalAlignment::Type arg4 ;
83520   Dali::Toolkit::TableView::CellPosition *argp2 ;
83521
83522   arg1 = (Dali::Toolkit::TableView *)jarg1;
83523   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83524   if (!argp2) {
83525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83526     return ;
83527   }
83528   arg2 = *argp2;
83529   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83530   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83531   {
83532     try {
83533       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83534     } catch (std::out_of_range& e) {
83535       {
83536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83537       };
83538     } catch (std::exception& e) {
83539       {
83540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (Dali::DaliException e) {
83543       {
83544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83545       };
83546     } catch (...) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83549       };
83550     }
83551   }
83552
83553 }
83554
83555
83556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83557   unsigned int jresult ;
83558   unsigned int result;
83559
83560   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83561   jresult = result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83567   int jresult ;
83568   int result;
83569
83570   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83571   jresult = (int)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83577   int jresult ;
83578   int result;
83579
83580   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83581   jresult = (int)result;
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83587   int jresult ;
83588   int result;
83589
83590   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83591   jresult = (int)result;
83592   return jresult;
83593 }
83594
83595
83596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83597   int jresult ;
83598   int result;
83599
83600   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83601   jresult = (int)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83607   int jresult ;
83608   int result;
83609
83610   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83611   jresult = (int)result;
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83617   int jresult ;
83618   int result;
83619
83620   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83621   jresult = (int)result;
83622   return jresult;
83623 }
83624
83625
83626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83627   int jresult ;
83628   int result;
83629
83630   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83631   jresult = (int)result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83637   int jresult ;
83638   int result;
83639
83640   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83641   jresult = (int)result;
83642   return jresult;
83643 }
83644
83645
83646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83647   int jresult ;
83648   int result;
83649
83650   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83651   jresult = (int)result;
83652   return jresult;
83653 }
83654
83655
83656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83657   int jresult ;
83658   int result;
83659
83660   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83661   jresult = (int)result;
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83667   int jresult ;
83668   int result;
83669
83670   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83671   jresult = (int)result;
83672   return jresult;
83673 }
83674
83675
83676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83677   int jresult ;
83678   int result;
83679
83680   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83681   jresult = (int)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83687   int jresult ;
83688   int result;
83689
83690   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83691   jresult = (int)result;
83692   return jresult;
83693 }
83694
83695
83696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83697   int jresult ;
83698   int result;
83699
83700   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83701   jresult = (int)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83707   int jresult ;
83708   int result;
83709
83710   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83711   jresult = (int)result;
83712   return jresult;
83713 }
83714
83715
83716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83717   int jresult ;
83718   int result;
83719
83720   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83721   jresult = (int)result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83727   int jresult ;
83728   int result;
83729
83730   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83731   jresult = (int)result;
83732   return jresult;
83733 }
83734
83735
83736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83737   int jresult ;
83738   int result;
83739
83740   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83741   jresult = (int)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83747   int jresult ;
83748   int result;
83749
83750   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83751   jresult = (int)result;
83752   return jresult;
83753 }
83754
83755
83756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83757   void * jresult ;
83758   Dali::Toolkit::TextLabel::Property *result = 0 ;
83759
83760   {
83761     try {
83762       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83763     } catch (std::out_of_range& e) {
83764       {
83765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83766       };
83767     } catch (std::exception& e) {
83768       {
83769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83770       };
83771     } catch (Dali::DaliException e) {
83772       {
83773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83774       };
83775     } catch (...) {
83776       {
83777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83778       };
83779     }
83780   }
83781
83782   jresult = (void *)result;
83783   return jresult;
83784 }
83785
83786
83787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83788   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83789
83790   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83791   {
83792     try {
83793       delete arg1;
83794     } catch (std::out_of_range& e) {
83795       {
83796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83797       };
83798     } catch (std::exception& e) {
83799       {
83800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83801       };
83802     } catch (Dali::DaliException e) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83805       };
83806     } catch (...) {
83807       {
83808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83809       };
83810     }
83811   }
83812
83813 }
83814
83815
83816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83817   void * jresult ;
83818   Dali::Toolkit::TextLabel result;
83819
83820   {
83821     try {
83822       result = Dali::Toolkit::TextLabel::New();
83823     } catch (std::out_of_range& e) {
83824       {
83825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (std::exception& e) {
83828       {
83829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (Dali::DaliException e) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83834       };
83835     } catch (...) {
83836       {
83837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83838       };
83839     }
83840   }
83841
83842   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83843   return jresult;
83844 }
83845
83846
83847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83848   void * jresult ;
83849   std::string *arg1 = 0 ;
83850   Dali::Toolkit::TextLabel result;
83851
83852   if (!jarg1) {
83853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83854     return 0;
83855   }
83856   std::string arg1_str(jarg1);
83857   arg1 = &arg1_str;
83858   {
83859     try {
83860       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83861     } catch (std::out_of_range& e) {
83862       {
83863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83864       };
83865     } catch (std::exception& e) {
83866       {
83867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83868       };
83869     } catch (Dali::DaliException e) {
83870       {
83871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83872       };
83873     } catch (...) {
83874       {
83875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83876       };
83877     }
83878   }
83879
83880   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83881
83882   //argout typemap for const std::string&
83883
83884   return jresult;
83885 }
83886
83887
83888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83889   void * jresult ;
83890   Dali::Toolkit::TextLabel *result = 0 ;
83891
83892   {
83893     try {
83894       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83895     } catch (std::out_of_range& e) {
83896       {
83897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (std::exception& e) {
83900       {
83901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83902       };
83903     } catch (Dali::DaliException e) {
83904       {
83905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83906       };
83907     } catch (...) {
83908       {
83909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83910       };
83911     }
83912   }
83913
83914   jresult = (void *)result;
83915   return jresult;
83916 }
83917
83918
83919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83920   void * jresult ;
83921   Dali::Toolkit::TextLabel *arg1 = 0 ;
83922   Dali::Toolkit::TextLabel *result = 0 ;
83923
83924   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83925   if (!arg1) {
83926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83927     return 0;
83928   }
83929   {
83930     try {
83931       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83932     } catch (std::out_of_range& e) {
83933       {
83934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83935       };
83936     } catch (std::exception& e) {
83937       {
83938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83939       };
83940     } catch (Dali::DaliException e) {
83941       {
83942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83943       };
83944     } catch (...) {
83945       {
83946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83947       };
83948     }
83949   }
83950
83951   jresult = (void *)result;
83952   return jresult;
83953 }
83954
83955
83956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83957   void * jresult ;
83958   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83959   Dali::Toolkit::TextLabel *arg2 = 0 ;
83960   Dali::Toolkit::TextLabel *result = 0 ;
83961
83962   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83963   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83964   if (!arg2) {
83965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83966     return 0;
83967   }
83968   {
83969     try {
83970       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (Dali::DaliException e) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83982       };
83983     } catch (...) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83986       };
83987     }
83988   }
83989
83990   jresult = (void *)result;
83991   return jresult;
83992 }
83993
83994
83995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83996   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83997
83998   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83999   {
84000     try {
84001       delete arg1;
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84009       };
84010     } catch (Dali::DaliException e) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84017       };
84018     }
84019   }
84020
84021 }
84022
84023
84024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84025   void * jresult ;
84026   Dali::BaseHandle arg1 ;
84027   Dali::BaseHandle *argp1 ;
84028   Dali::Toolkit::TextLabel result;
84029
84030   argp1 = (Dali::BaseHandle *)jarg1;
84031   if (!argp1) {
84032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84033     return 0;
84034   }
84035   arg1 = *argp1;
84036   {
84037     try {
84038       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (Dali::DaliException e) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84054       };
84055     }
84056   }
84057
84058   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84064   void * jresult ;
84065   Dali::Toolkit::AccessibilityManager *result = 0 ;
84066
84067   {
84068     try {
84069       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84070     } catch (std::out_of_range& e) {
84071       {
84072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84073       };
84074     } catch (std::exception& e) {
84075       {
84076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84077       };
84078     } catch (Dali::DaliException e) {
84079       {
84080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84081       };
84082     } catch (...) {
84083       {
84084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84085       };
84086     }
84087   }
84088
84089   jresult = (void *)result;
84090   return jresult;
84091 }
84092
84093
84094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84096
84097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84098   {
84099     try {
84100       delete arg1;
84101     } catch (std::out_of_range& e) {
84102       {
84103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84104       };
84105     } catch (std::exception& e) {
84106       {
84107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84108       };
84109     } catch (Dali::DaliException e) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84112       };
84113     } catch (...) {
84114       {
84115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84116       };
84117     }
84118   }
84119
84120 }
84121
84122
84123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84124   void * jresult ;
84125   Dali::Toolkit::AccessibilityManager result;
84126
84127   {
84128     try {
84129       result = Dali::Toolkit::AccessibilityManager::Get();
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (Dali::DaliException e) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84141       };
84142     } catch (...) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84145       };
84146     }
84147   }
84148
84149   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84150   return jresult;
84151 }
84152
84153
84154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84155   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84156   Dali::Actor arg2 ;
84157   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84158   std::string *arg4 = 0 ;
84159   Dali::Actor *argp2 ;
84160
84161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84162   argp2 = (Dali::Actor *)jarg2;
84163   if (!argp2) {
84164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84165     return ;
84166   }
84167   arg2 = *argp2;
84168   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84169   if (!jarg4) {
84170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84171     return ;
84172   }
84173   std::string arg4_str(jarg4);
84174   arg4 = &arg4_str;
84175   {
84176     try {
84177       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84178     } catch (std::out_of_range& e) {
84179       {
84180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84181       };
84182     } catch (std::exception& e) {
84183       {
84184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84185       };
84186     } catch (Dali::DaliException e) {
84187       {
84188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84193       };
84194     }
84195   }
84196
84197
84198   //argout typemap for const std::string&
84199
84200 }
84201
84202
84203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84204   char * jresult ;
84205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84206   Dali::Actor arg2 ;
84207   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84208   Dali::Actor *argp2 ;
84209   std::string result;
84210
84211   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84212   argp2 = (Dali::Actor *)jarg2;
84213   if (!argp2) {
84214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84215     return 0;
84216   }
84217   arg2 = *argp2;
84218   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84219   {
84220     try {
84221       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84222     } catch (std::out_of_range& e) {
84223       {
84224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84225       };
84226     } catch (std::exception& e) {
84227       {
84228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84229       };
84230     } catch (Dali::DaliException e) {
84231       {
84232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84233       };
84234     } catch (...) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84237       };
84238     }
84239   }
84240
84241   jresult = SWIG_csharp_string_callback((&result)->c_str());
84242   return jresult;
84243 }
84244
84245
84246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84248   Dali::Actor arg2 ;
84249   unsigned int arg3 ;
84250   Dali::Actor *argp2 ;
84251
84252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84253   argp2 = (Dali::Actor *)jarg2;
84254   if (!argp2) {
84255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84256     return ;
84257   }
84258   arg2 = *argp2;
84259   arg3 = (unsigned int)jarg3;
84260   {
84261     try {
84262       (arg1)->SetFocusOrder(arg2,arg3);
84263     } catch (std::out_of_range& e) {
84264       {
84265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84266       };
84267     } catch (std::exception& e) {
84268       {
84269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (Dali::DaliException e) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84274       };
84275     } catch (...) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84278       };
84279     }
84280   }
84281
84282 }
84283
84284
84285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84286   unsigned int jresult ;
84287   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84288   Dali::Actor arg2 ;
84289   Dali::Actor *argp2 ;
84290   unsigned int result;
84291
84292   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84293   argp2 = (Dali::Actor *)jarg2;
84294   if (!argp2) {
84295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84296     return 0;
84297   }
84298   arg2 = *argp2;
84299   {
84300     try {
84301       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84302     } catch (std::out_of_range& e) {
84303       {
84304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84305       };
84306     } catch (std::exception& e) {
84307       {
84308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84309       };
84310     } catch (Dali::DaliException e) {
84311       {
84312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84313       };
84314     } catch (...) {
84315       {
84316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84317       };
84318     }
84319   }
84320
84321   jresult = result;
84322   return jresult;
84323 }
84324
84325
84326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84327   unsigned int jresult ;
84328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84329   unsigned int result;
84330
84331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84332   {
84333     try {
84334       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84335     } catch (std::out_of_range& e) {
84336       {
84337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84338       };
84339     } catch (std::exception& e) {
84340       {
84341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84342       };
84343     } catch (Dali::DaliException e) {
84344       {
84345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84346       };
84347     } catch (...) {
84348       {
84349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84350       };
84351     }
84352   }
84353
84354   jresult = result;
84355   return jresult;
84356 }
84357
84358
84359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84360   void * jresult ;
84361   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84362   unsigned int arg2 ;
84363   Dali::Actor result;
84364
84365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84366   arg2 = (unsigned int)jarg2;
84367   {
84368     try {
84369       result = (arg1)->GetActorByFocusOrder(arg2);
84370     } catch (std::out_of_range& e) {
84371       {
84372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84373       };
84374     } catch (std::exception& e) {
84375       {
84376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84377       };
84378     } catch (Dali::DaliException e) {
84379       {
84380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84381       };
84382     } catch (...) {
84383       {
84384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84385       };
84386     }
84387   }
84388
84389   jresult = new Dali::Actor((const Dali::Actor &)result);
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84395   unsigned int jresult ;
84396   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84397   Dali::Actor arg2 ;
84398   Dali::Actor *argp2 ;
84399   bool result;
84400
84401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84402   argp2 = (Dali::Actor *)jarg2;
84403   if (!argp2) {
84404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84405     return 0;
84406   }
84407   arg2 = *argp2;
84408   {
84409     try {
84410       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (Dali::DaliException e) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84422       };
84423     } catch (...) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84426       };
84427     }
84428   }
84429
84430   jresult = result;
84431   return jresult;
84432 }
84433
84434
84435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84436   void * jresult ;
84437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84438   Dali::Actor result;
84439
84440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84441   {
84442     try {
84443       result = (arg1)->GetCurrentFocusActor();
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84451       };
84452     } catch (Dali::DaliException e) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84455       };
84456     } catch (...) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84459       };
84460     }
84461   }
84462
84463   jresult = new Dali::Actor((const Dali::Actor &)result);
84464   return jresult;
84465 }
84466
84467
84468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84469   void * jresult ;
84470   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84471   Dali::Actor result;
84472
84473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84474   {
84475     try {
84476       result = (arg1)->GetCurrentFocusGroup();
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (Dali::DaliException e) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84492       };
84493     }
84494   }
84495
84496   jresult = new Dali::Actor((const Dali::Actor &)result);
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84502   unsigned int jresult ;
84503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84504   unsigned int result;
84505
84506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84507   {
84508     try {
84509       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84510     } catch (std::out_of_range& e) {
84511       {
84512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84513       };
84514     } catch (std::exception& e) {
84515       {
84516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (Dali::DaliException e) {
84519       {
84520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84521       };
84522     } catch (...) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84525       };
84526     }
84527   }
84528
84529   jresult = result;
84530   return jresult;
84531 }
84532
84533
84534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84535   unsigned int jresult ;
84536   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84537   bool result;
84538
84539   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84540   {
84541     try {
84542       result = (bool)(arg1)->MoveFocusForward();
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (Dali::DaliException e) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561
84562   jresult = result;
84563   return jresult;
84564 }
84565
84566
84567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84568   unsigned int jresult ;
84569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84570   bool result;
84571
84572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84573   {
84574     try {
84575       result = (bool)(arg1)->MoveFocusBackward();
84576     } catch (std::out_of_range& e) {
84577       {
84578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84579       };
84580     } catch (std::exception& e) {
84581       {
84582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84583       };
84584     } catch (Dali::DaliException e) {
84585       {
84586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84587       };
84588     } catch (...) {
84589       {
84590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84591       };
84592     }
84593   }
84594
84595   jresult = result;
84596   return jresult;
84597 }
84598
84599
84600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84601   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84602
84603   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84604   {
84605     try {
84606       (arg1)->ClearFocus();
84607     } catch (std::out_of_range& e) {
84608       {
84609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84610       };
84611     } catch (std::exception& e) {
84612       {
84613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84614       };
84615     } catch (Dali::DaliException e) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84622       };
84623     }
84624   }
84625
84626 }
84627
84628
84629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84631
84632   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84633   {
84634     try {
84635       (arg1)->Reset();
84636     } catch (std::out_of_range& e) {
84637       {
84638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84639       };
84640     } catch (std::exception& e) {
84641       {
84642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84643       };
84644     } catch (Dali::DaliException e) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84647       };
84648     } catch (...) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84651       };
84652     }
84653   }
84654
84655 }
84656
84657
84658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84660   Dali::Actor arg2 ;
84661   bool arg3 ;
84662   Dali::Actor *argp2 ;
84663
84664   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84665   argp2 = (Dali::Actor *)jarg2;
84666   if (!argp2) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84668     return ;
84669   }
84670   arg2 = *argp2;
84671   arg3 = jarg3 ? true : false;
84672   {
84673     try {
84674       (arg1)->SetFocusGroup(arg2,arg3);
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84690       };
84691     }
84692   }
84693
84694 }
84695
84696
84697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84698   unsigned int jresult ;
84699   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84700   Dali::Actor arg2 ;
84701   Dali::Actor *argp2 ;
84702   bool result;
84703
84704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84705   argp2 = (Dali::Actor *)jarg2;
84706   if (!argp2) {
84707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84708     return 0;
84709   }
84710   arg2 = *argp2;
84711   {
84712     try {
84713       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84714     } catch (std::out_of_range& e) {
84715       {
84716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84717       };
84718     } catch (std::exception& e) {
84719       {
84720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84721       };
84722     } catch (Dali::DaliException e) {
84723       {
84724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84725       };
84726     } catch (...) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84729       };
84730     }
84731   }
84732
84733   jresult = result;
84734   return jresult;
84735 }
84736
84737
84738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84740   bool arg2 ;
84741
84742   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84743   arg2 = jarg2 ? true : false;
84744   {
84745     try {
84746       (arg1)->SetGroupMode(arg2);
84747     } catch (std::out_of_range& e) {
84748       {
84749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84750       };
84751     } catch (std::exception& e) {
84752       {
84753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84754       };
84755     } catch (Dali::DaliException e) {
84756       {
84757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84762       };
84763     }
84764   }
84765
84766 }
84767
84768
84769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84770   unsigned int jresult ;
84771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84772   bool result;
84773
84774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84775   {
84776     try {
84777       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84778     } catch (std::out_of_range& e) {
84779       {
84780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (std::exception& e) {
84783       {
84784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84785       };
84786     } catch (Dali::DaliException e) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84789       };
84790     } catch (...) {
84791       {
84792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84793       };
84794     }
84795   }
84796
84797   jresult = result;
84798   return jresult;
84799 }
84800
84801
84802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84804   bool arg2 ;
84805
84806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84807   arg2 = jarg2 ? true : false;
84808   {
84809     try {
84810       (arg1)->SetWrapMode(arg2);
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84826       };
84827     }
84828   }
84829
84830 }
84831
84832
84833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84834   unsigned int jresult ;
84835   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84836   bool result;
84837
84838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84839   {
84840     try {
84841       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84842     } catch (std::out_of_range& e) {
84843       {
84844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84845       };
84846     } catch (std::exception& e) {
84847       {
84848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84849       };
84850     } catch (Dali::DaliException e) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84853       };
84854     } catch (...) {
84855       {
84856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84857       };
84858     }
84859   }
84860
84861   jresult = result;
84862   return jresult;
84863 }
84864
84865
84866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84867   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84868   Dali::Actor arg2 ;
84869   Dali::Actor *argp2 ;
84870
84871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84872   argp2 = (Dali::Actor *)jarg2;
84873   if (!argp2) {
84874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84875     return ;
84876   }
84877   arg2 = *argp2;
84878   {
84879     try {
84880       (arg1)->SetFocusIndicatorActor(arg2);
84881     } catch (std::out_of_range& e) {
84882       {
84883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84884       };
84885     } catch (std::exception& e) {
84886       {
84887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84888       };
84889     } catch (Dali::DaliException e) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84896       };
84897     }
84898   }
84899
84900 }
84901
84902
84903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84904   void * jresult ;
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   Dali::Actor result;
84907
84908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84909   {
84910     try {
84911       result = (arg1)->GetFocusIndicatorActor();
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (Dali::DaliException e) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930
84931   jresult = new Dali::Actor((const Dali::Actor &)result);
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84937   void * jresult ;
84938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84939   Dali::Actor arg2 ;
84940   Dali::Actor *argp2 ;
84941   Dali::Actor result;
84942
84943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84944   argp2 = (Dali::Actor *)jarg2;
84945   if (!argp2) {
84946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84947     return 0;
84948   }
84949   arg2 = *argp2;
84950   {
84951     try {
84952       result = (arg1)->GetFocusGroup(arg2);
84953     } catch (std::out_of_range& e) {
84954       {
84955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84956       };
84957     } catch (std::exception& e) {
84958       {
84959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84960       };
84961     } catch (Dali::DaliException e) {
84962       {
84963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84964       };
84965     } catch (...) {
84966       {
84967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84968       };
84969     }
84970   }
84971
84972   jresult = new Dali::Actor((const Dali::Actor &)result);
84973   return jresult;
84974 }
84975
84976
84977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84978   void * jresult ;
84979   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84980   Dali::Vector2 result;
84981
84982   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84983   {
84984     try {
84985       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84986     } catch (std::out_of_range& e) {
84987       {
84988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (std::exception& e) {
84991       {
84992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84993       };
84994     } catch (Dali::DaliException e) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84997       };
84998     } catch (...) {
84999       {
85000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85001       };
85002     }
85003   }
85004
85005   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85006   return jresult;
85007 }
85008
85009
85010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85011   void * jresult ;
85012   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85013   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85014
85015   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85016   {
85017     try {
85018       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85019     } catch (std::out_of_range& e) {
85020       {
85021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85022       };
85023     } catch (std::exception& e) {
85024       {
85025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (Dali::DaliException e) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85030       };
85031     } catch (...) {
85032       {
85033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85034       };
85035     }
85036   }
85037
85038   jresult = (void *)result;
85039   return jresult;
85040 }
85041
85042
85043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85044   void * jresult ;
85045   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85046   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85047
85048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85049   {
85050     try {
85051       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85052     } catch (std::out_of_range& e) {
85053       {
85054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (std::exception& e) {
85057       {
85058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85059       };
85060     } catch (Dali::DaliException e) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85063       };
85064     } catch (...) {
85065       {
85066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85067       };
85068     }
85069   }
85070
85071   jresult = (void *)result;
85072   return jresult;
85073 }
85074
85075
85076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85077   void * jresult ;
85078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85079   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85080
85081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85082   {
85083     try {
85084       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85085     } catch (std::out_of_range& e) {
85086       {
85087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85088       };
85089     } catch (std::exception& e) {
85090       {
85091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85092       };
85093     } catch (Dali::DaliException e) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85096       };
85097     } catch (...) {
85098       {
85099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85100       };
85101     }
85102   }
85103
85104   jresult = (void *)result;
85105   return jresult;
85106 }
85107
85108
85109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85110   void * jresult ;
85111   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85112   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85113
85114   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85115   {
85116     try {
85117       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85133       };
85134     }
85135   }
85136
85137   jresult = (void *)result;
85138   return jresult;
85139 }
85140
85141
85142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85143   void * jresult ;
85144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85145   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85146
85147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85148   {
85149     try {
85150       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85151     } catch (std::out_of_range& e) {
85152       {
85153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85154       };
85155     } catch (std::exception& e) {
85156       {
85157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (Dali::DaliException e) {
85160       {
85161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85162       };
85163     } catch (...) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85166       };
85167     }
85168   }
85169
85170   jresult = (void *)result;
85171   return jresult;
85172 }
85173
85174
85175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85176   void * jresult ;
85177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85178   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85179
85180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85181   {
85182     try {
85183       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85184     } catch (std::out_of_range& e) {
85185       {
85186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85187       };
85188     } catch (std::exception& e) {
85189       {
85190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85191       };
85192     } catch (Dali::DaliException e) {
85193       {
85194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85195       };
85196     } catch (...) {
85197       {
85198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85199       };
85200     }
85201   }
85202
85203   jresult = (void *)result;
85204   return jresult;
85205 }
85206
85207
85208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85209   void * jresult ;
85210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85211   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85212
85213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85214   {
85215     try {
85216       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85217     } catch (std::out_of_range& e) {
85218       {
85219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85220       };
85221     } catch (std::exception& e) {
85222       {
85223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85224       };
85225     } catch (Dali::DaliException e) {
85226       {
85227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85228       };
85229     } catch (...) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85232       };
85233     }
85234   }
85235
85236   jresult = (void *)result;
85237   return jresult;
85238 }
85239
85240
85241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85242   void * jresult ;
85243   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85244   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85245
85246   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85247   {
85248     try {
85249       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85250     } catch (std::out_of_range& e) {
85251       {
85252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (std::exception& e) {
85255       {
85256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85257       };
85258     } catch (Dali::DaliException e) {
85259       {
85260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85261       };
85262     } catch (...) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85265       };
85266     }
85267   }
85268
85269   jresult = (void *)result;
85270   return jresult;
85271 }
85272
85273
85274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85275   void * jresult ;
85276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85277   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85278
85279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85280   {
85281     try {
85282       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85283     } catch (std::out_of_range& e) {
85284       {
85285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85286       };
85287     } catch (std::exception& e) {
85288       {
85289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85290       };
85291     } catch (Dali::DaliException e) {
85292       {
85293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85294       };
85295     } catch (...) {
85296       {
85297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85298       };
85299     }
85300   }
85301
85302   jresult = (void *)result;
85303   return jresult;
85304 }
85305
85306
85307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85308   void * jresult ;
85309   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85310   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85311
85312   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85313   {
85314     try {
85315       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85316     } catch (std::out_of_range& e) {
85317       {
85318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85319       };
85320     } catch (std::exception& e) {
85321       {
85322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85323       };
85324     } catch (Dali::DaliException e) {
85325       {
85326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85327       };
85328     } catch (...) {
85329       {
85330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85331       };
85332     }
85333   }
85334
85335   jresult = (void *)result;
85336   return jresult;
85337 }
85338
85339
85340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85341   void * jresult ;
85342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85343   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85344
85345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85346   {
85347     try {
85348       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85349     } catch (std::out_of_range& e) {
85350       {
85351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85352       };
85353     } catch (std::exception& e) {
85354       {
85355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (Dali::DaliException e) {
85358       {
85359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85364       };
85365     }
85366   }
85367
85368   jresult = (void *)result;
85369   return jresult;
85370 }
85371
85372
85373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85374   void * jresult ;
85375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85377
85378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85379   {
85380     try {
85381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85382     } catch (std::out_of_range& e) {
85383       {
85384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (std::exception& e) {
85387       {
85388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85389       };
85390     } catch (Dali::DaliException e) {
85391       {
85392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85393       };
85394     } catch (...) {
85395       {
85396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85397       };
85398     }
85399   }
85400
85401   jresult = (void *)result;
85402   return jresult;
85403 }
85404
85405
85406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85407   void * jresult ;
85408   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85409   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85410
85411   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85412   {
85413     try {
85414       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85415     } catch (std::out_of_range& e) {
85416       {
85417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85418       };
85419     } catch (std::exception& e) {
85420       {
85421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (Dali::DaliException e) {
85424       {
85425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85426       };
85427     } catch (...) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85430       };
85431     }
85432   }
85433
85434   jresult = (void *)result;
85435   return jresult;
85436 }
85437
85438
85439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85440   void * jresult ;
85441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85442   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85443
85444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85445   {
85446     try {
85447       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85448     } catch (std::out_of_range& e) {
85449       {
85450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85451       };
85452     } catch (std::exception& e) {
85453       {
85454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (Dali::DaliException e) {
85457       {
85458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85459       };
85460     } catch (...) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85463       };
85464     }
85465   }
85466
85467   jresult = (void *)result;
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85473   void * jresult ;
85474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85475   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85476
85477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85478   {
85479     try {
85480       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85481     } catch (std::out_of_range& e) {
85482       {
85483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85484       };
85485     } catch (std::exception& e) {
85486       {
85487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85488       };
85489     } catch (Dali::DaliException e) {
85490       {
85491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85492       };
85493     } catch (...) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85496       };
85497     }
85498   }
85499
85500   jresult = (void *)result;
85501   return jresult;
85502 }
85503
85504
85505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85506   void * jresult ;
85507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85508   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85509
85510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85511   {
85512     try {
85513       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85514     } catch (std::out_of_range& e) {
85515       {
85516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85517       };
85518     } catch (std::exception& e) {
85519       {
85520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85521       };
85522     } catch (Dali::DaliException e) {
85523       {
85524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85525       };
85526     } catch (...) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85529       };
85530     }
85531   }
85532
85533   jresult = (void *)result;
85534   return jresult;
85535 }
85536
85537
85538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85539   void * jresult ;
85540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85541   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85542
85543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85544   {
85545     try {
85546       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85547     } catch (std::out_of_range& e) {
85548       {
85549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (std::exception& e) {
85552       {
85553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (Dali::DaliException e) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85558       };
85559     } catch (...) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85562       };
85563     }
85564   }
85565
85566   jresult = (void *)result;
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85572   void * jresult ;
85573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85574   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85575
85576   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85577   {
85578     try {
85579       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85580     } catch (std::out_of_range& e) {
85581       {
85582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85583       };
85584     } catch (std::exception& e) {
85585       {
85586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (Dali::DaliException e) {
85589       {
85590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85591       };
85592     } catch (...) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85595       };
85596     }
85597   }
85598
85599   jresult = (void *)result;
85600   return jresult;
85601 }
85602
85603
85604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85605   void * jresult ;
85606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85607   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85608
85609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85610   {
85611     try {
85612       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85613     } catch (std::out_of_range& e) {
85614       {
85615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85616       };
85617     } catch (std::exception& e) {
85618       {
85619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (Dali::DaliException e) {
85622       {
85623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85624       };
85625     } catch (...) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85628       };
85629     }
85630   }
85631
85632   jresult = (void *)result;
85633   return jresult;
85634 }
85635
85636
85637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85638   void * jresult ;
85639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85640   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85641
85642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85643   {
85644     try {
85645       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85646     } catch (std::out_of_range& e) {
85647       {
85648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85649       };
85650     } catch (std::exception& e) {
85651       {
85652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85653       };
85654     } catch (Dali::DaliException e) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85657       };
85658     } catch (...) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85661       };
85662     }
85663   }
85664
85665   jresult = (void *)result;
85666   return jresult;
85667 }
85668
85669
85670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85671   void * jresult ;
85672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85673   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85674
85675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85676   {
85677     try {
85678       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (Dali::DaliException e) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85694       };
85695     }
85696   }
85697
85698   jresult = (void *)result;
85699   return jresult;
85700 }
85701
85702
85703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85704   void * jresult ;
85705   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85706   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85707
85708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85709   {
85710     try {
85711       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85712     } catch (std::out_of_range& e) {
85713       {
85714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85715       };
85716     } catch (std::exception& e) {
85717       {
85718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (Dali::DaliException e) {
85721       {
85722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85723       };
85724     } catch (...) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85727       };
85728     }
85729   }
85730
85731   jresult = (void *)result;
85732   return jresult;
85733 }
85734
85735
85736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85737   void * jresult ;
85738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85739   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85740
85741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85742   {
85743     try {
85744       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85745     } catch (std::out_of_range& e) {
85746       {
85747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85748       };
85749     } catch (std::exception& e) {
85750       {
85751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (Dali::DaliException e) {
85754       {
85755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85756       };
85757     } catch (...) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85760       };
85761     }
85762   }
85763
85764   jresult = (void *)result;
85765   return jresult;
85766 }
85767
85768
85769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85770   void * jresult ;
85771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85772   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85773
85774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85775   {
85776     try {
85777       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85778     } catch (std::out_of_range& e) {
85779       {
85780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (std::exception& e) {
85783       {
85784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (Dali::DaliException e) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85789       };
85790     } catch (...) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85793       };
85794     }
85795   }
85796
85797   jresult = (void *)result;
85798   return jresult;
85799 }
85800
85801
85802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85803   void * jresult ;
85804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85805   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85806
85807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85808   {
85809     try {
85810       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85811     } catch (std::out_of_range& e) {
85812       {
85813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85814       };
85815     } catch (std::exception& e) {
85816       {
85817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85818       };
85819     } catch (Dali::DaliException e) {
85820       {
85821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85822       };
85823     } catch (...) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85826       };
85827     }
85828   }
85829
85830   jresult = (void *)result;
85831   return jresult;
85832 }
85833
85834
85835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85836   void * jresult ;
85837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85838   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85839
85840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85841   {
85842     try {
85843       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85844     } catch (std::out_of_range& e) {
85845       {
85846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85847       };
85848     } catch (std::exception& e) {
85849       {
85850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (Dali::DaliException e) {
85853       {
85854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85855       };
85856     } catch (...) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85859       };
85860     }
85861   }
85862
85863   jresult = (void *)result;
85864   return jresult;
85865 }
85866
85867
85868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85869   void * jresult ;
85870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85871   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85872
85873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85874   {
85875     try {
85876       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85877     } catch (std::out_of_range& e) {
85878       {
85879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85880       };
85881     } catch (std::exception& e) {
85882       {
85883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85884       };
85885     } catch (Dali::DaliException e) {
85886       {
85887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85888       };
85889     } catch (...) {
85890       {
85891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85892       };
85893     }
85894   }
85895
85896   jresult = (void *)result;
85897   return jresult;
85898 }
85899
85900
85901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85902   void * jresult ;
85903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85904   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85905
85906   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85907   {
85908     try {
85909       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85910     } catch (std::out_of_range& e) {
85911       {
85912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85913       };
85914     } catch (std::exception& e) {
85915       {
85916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (Dali::DaliException e) {
85919       {
85920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85921       };
85922     } catch (...) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85925       };
85926     }
85927   }
85928
85929   jresult = (void *)result;
85930   return jresult;
85931 }
85932
85933
85934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85935   void * jresult ;
85936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85938
85939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85940   {
85941     try {
85942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85943     } catch (std::out_of_range& e) {
85944       {
85945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85946       };
85947     } catch (std::exception& e) {
85948       {
85949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (Dali::DaliException e) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85954       };
85955     } catch (...) {
85956       {
85957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85958       };
85959     }
85960   }
85961
85962   jresult = (void *)result;
85963   return jresult;
85964 }
85965
85966
85967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85968   void * jresult ;
85969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85970   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85971
85972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85973   {
85974     try {
85975       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85976     } catch (std::out_of_range& e) {
85977       {
85978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (std::exception& e) {
85981       {
85982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (Dali::DaliException e) {
85985       {
85986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85987       };
85988     } catch (...) {
85989       {
85990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85991       };
85992     }
85993   }
85994
85995   jresult = (void *)result;
85996   return jresult;
85997 }
85998
85999
86000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86001   void * jresult ;
86002   Dali::Toolkit::StyleManager *result = 0 ;
86003
86004   {
86005     try {
86006       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86007     } catch (std::out_of_range& e) {
86008       {
86009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86010       };
86011     } catch (std::exception& e) {
86012       {
86013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86014       };
86015     } catch (Dali::DaliException e) {
86016       {
86017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86018       };
86019     } catch (...) {
86020       {
86021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86022       };
86023     }
86024   }
86025
86026   jresult = (void *)result;
86027   return jresult;
86028 }
86029
86030
86031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86032   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86033
86034   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86035   {
86036     try {
86037       delete arg1;
86038     } catch (std::out_of_range& e) {
86039       {
86040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86041       };
86042     } catch (std::exception& e) {
86043       {
86044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86045       };
86046     } catch (Dali::DaliException e) {
86047       {
86048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86049       };
86050     } catch (...) {
86051       {
86052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86053       };
86054     }
86055   }
86056
86057 }
86058
86059
86060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86061   void * jresult ;
86062   Dali::Toolkit::StyleManager result;
86063
86064   {
86065     try {
86066       result = Dali::Toolkit::StyleManager::Get();
86067     } catch (std::out_of_range& e) {
86068       {
86069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (std::exception& e) {
86072       {
86073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (Dali::DaliException e) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085
86086   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86087   return jresult;
86088 }
86089
86090
86091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86092   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86093   std::string *arg2 = 0 ;
86094
86095   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86096   if (!jarg2) {
86097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86098     return ;
86099   }
86100   std::string arg2_str(jarg2);
86101   arg2 = &arg2_str;
86102   {
86103     try {
86104       (arg1)->ApplyTheme((std::string const &)*arg2);
86105     } catch (std::out_of_range& e) {
86106       {
86107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86108       };
86109     } catch (std::exception& e) {
86110       {
86111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86112       };
86113     } catch (Dali::DaliException e) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86116       };
86117     } catch (...) {
86118       {
86119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86120       };
86121     }
86122   }
86123
86124
86125   //argout typemap for const std::string&
86126
86127 }
86128
86129
86130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86131   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86132
86133   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86134   {
86135     try {
86136       (arg1)->ApplyDefaultTheme();
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86144       };
86145     } catch (Dali::DaliException e) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86152       };
86153     }
86154   }
86155
86156 }
86157
86158
86159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86160   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86161   std::string *arg2 = 0 ;
86162   Dali::Property::Value *arg3 = 0 ;
86163
86164   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86165   if (!jarg2) {
86166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86167     return ;
86168   }
86169   std::string arg2_str(jarg2);
86170   arg2 = &arg2_str;
86171   arg3 = (Dali::Property::Value *)jarg3;
86172   if (!arg3) {
86173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86174     return ;
86175   }
86176   {
86177     try {
86178       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86179     } catch (std::out_of_range& e) {
86180       {
86181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86182       };
86183     } catch (std::exception& e) {
86184       {
86185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86186       };
86187     } catch (Dali::DaliException e) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86190       };
86191     } catch (...) {
86192       {
86193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86194       };
86195     }
86196   }
86197
86198
86199   //argout typemap for const std::string&
86200
86201 }
86202
86203
86204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86205   unsigned int jresult ;
86206   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86207   std::string *arg2 = 0 ;
86208   Dali::Property::Value *arg3 = 0 ;
86209   bool result;
86210
86211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86212   if (!jarg2) {
86213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86214     return 0;
86215   }
86216   std::string arg2_str(jarg2);
86217   arg2 = &arg2_str;
86218   arg3 = (Dali::Property::Value *)jarg3;
86219   if (!arg3) {
86220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86221     return 0;
86222   }
86223   {
86224     try {
86225       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86226     } catch (std::out_of_range& e) {
86227       {
86228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (std::exception& e) {
86231       {
86232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86233       };
86234     } catch (Dali::DaliException e) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86237       };
86238     } catch (...) {
86239       {
86240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86241       };
86242     }
86243   }
86244
86245   jresult = result;
86246
86247   //argout typemap for const std::string&
86248
86249   return jresult;
86250 }
86251
86252
86253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86254   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86255   Dali::Toolkit::Control arg2 ;
86256   std::string *arg3 = 0 ;
86257   std::string *arg4 = 0 ;
86258   Dali::Toolkit::Control *argp2 ;
86259
86260   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86261   argp2 = (Dali::Toolkit::Control *)jarg2;
86262   if (!argp2) {
86263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86264     return ;
86265   }
86266   arg2 = *argp2;
86267   if (!jarg3) {
86268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86269     return ;
86270   }
86271   std::string arg3_str(jarg3);
86272   arg3 = &arg3_str;
86273   if (!jarg4) {
86274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86275     return ;
86276   }
86277   std::string arg4_str(jarg4);
86278   arg4 = &arg4_str;
86279   {
86280     try {
86281       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86282     } catch (std::out_of_range& e) {
86283       {
86284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86285       };
86286     } catch (std::exception& e) {
86287       {
86288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86289       };
86290     } catch (Dali::DaliException e) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86293       };
86294     } catch (...) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86297       };
86298     }
86299   }
86300
86301
86302   //argout typemap for const std::string&
86303
86304
86305   //argout typemap for const std::string&
86306
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86311   void * jresult ;
86312   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86313   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86314
86315   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86316   {
86317     try {
86318       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (Dali::DaliException e) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86330       };
86331     } catch (...) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86334       };
86335     }
86336   }
86337
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86344   int jresult ;
86345   int result;
86346
86347   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86348   jresult = (int)result;
86349   return jresult;
86350 }
86351
86352
86353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86354   int jresult ;
86355   int result;
86356
86357   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86358   jresult = (int)result;
86359   return jresult;
86360 }
86361
86362
86363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86364   int jresult ;
86365   int result;
86366
86367   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86368   jresult = (int)result;
86369   return jresult;
86370 }
86371
86372
86373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86374   int jresult ;
86375   int result;
86376
86377   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86378   jresult = (int)result;
86379   return jresult;
86380 }
86381
86382
86383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86384   int jresult ;
86385   int result;
86386
86387   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86388   jresult = (int)result;
86389   return jresult;
86390 }
86391
86392
86393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86394   int jresult ;
86395   int result;
86396
86397   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86398   jresult = (int)result;
86399   return jresult;
86400 }
86401
86402
86403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86404   int jresult ;
86405   int result;
86406
86407   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86408   jresult = (int)result;
86409   return jresult;
86410 }
86411
86412
86413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86414   int jresult ;
86415   int result;
86416
86417   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86418   jresult = (int)result;
86419   return jresult;
86420 }
86421
86422
86423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86424   int jresult ;
86425   int result;
86426
86427   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86428   jresult = (int)result;
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86434   int jresult ;
86435   int result;
86436
86437   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86438   jresult = (int)result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86444   int jresult ;
86445   int result;
86446
86447   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86448   jresult = (int)result;
86449   return jresult;
86450 }
86451
86452
86453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86454   int jresult ;
86455   int result;
86456
86457   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86458   jresult = (int)result;
86459   return jresult;
86460 }
86461
86462
86463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86464   int jresult ;
86465   int result;
86466
86467   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86468   jresult = (int)result;
86469   return jresult;
86470 }
86471
86472
86473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86474   int jresult ;
86475   int result;
86476
86477   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86478   jresult = (int)result;
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86484   int jresult ;
86485   int result;
86486
86487   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86488   jresult = (int)result;
86489   return jresult;
86490 }
86491
86492
86493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86494   void * jresult ;
86495   Dali::Toolkit::Slider::Property *result = 0 ;
86496
86497   {
86498     try {
86499       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86500     } catch (std::out_of_range& e) {
86501       {
86502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (std::exception& e) {
86505       {
86506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86507       };
86508     } catch (Dali::DaliException e) {
86509       {
86510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86511       };
86512     } catch (...) {
86513       {
86514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86515       };
86516     }
86517   }
86518
86519   jresult = (void *)result;
86520   return jresult;
86521 }
86522
86523
86524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86525   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86526
86527   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86528   {
86529     try {
86530       delete arg1;
86531     } catch (std::out_of_range& e) {
86532       {
86533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86534       };
86535     } catch (std::exception& e) {
86536       {
86537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86538       };
86539     } catch (Dali::DaliException e) {
86540       {
86541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86542       };
86543     } catch (...) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86546       };
86547     }
86548   }
86549
86550 }
86551
86552
86553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86554   void * jresult ;
86555   Dali::Toolkit::Slider result;
86556
86557   {
86558     try {
86559       result = Dali::Toolkit::Slider::New();
86560     } catch (std::out_of_range& e) {
86561       {
86562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (std::exception& e) {
86565       {
86566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86567       };
86568     } catch (Dali::DaliException e) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86571       };
86572     } catch (...) {
86573       {
86574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86575       };
86576     }
86577   }
86578
86579   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86580   return jresult;
86581 }
86582
86583
86584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86585   void * jresult ;
86586   Dali::Toolkit::Slider *result = 0 ;
86587
86588   {
86589     try {
86590       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86591     } catch (std::out_of_range& e) {
86592       {
86593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (std::exception& e) {
86596       {
86597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (Dali::DaliException e) {
86600       {
86601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86602       };
86603     } catch (...) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86606       };
86607     }
86608   }
86609
86610   jresult = (void *)result;
86611   return jresult;
86612 }
86613
86614
86615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86616   void * jresult ;
86617   Dali::Toolkit::Slider *arg1 = 0 ;
86618   Dali::Toolkit::Slider *result = 0 ;
86619
86620   arg1 = (Dali::Toolkit::Slider *)jarg1;
86621   if (!arg1) {
86622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86623     return 0;
86624   }
86625   {
86626     try {
86627       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86628     } catch (std::out_of_range& e) {
86629       {
86630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86631       };
86632     } catch (std::exception& e) {
86633       {
86634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (Dali::DaliException e) {
86637       {
86638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86643       };
86644     }
86645   }
86646
86647   jresult = (void *)result;
86648   return jresult;
86649 }
86650
86651
86652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86653   void * jresult ;
86654   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86655   Dali::Toolkit::Slider *arg2 = 0 ;
86656   Dali::Toolkit::Slider *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::Slider *)jarg1;
86659   arg2 = (Dali::Toolkit::Slider *)jarg2;
86660   if (!arg2) {
86661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86662     return 0;
86663   }
86664   {
86665     try {
86666       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86667     } catch (std::out_of_range& e) {
86668       {
86669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86670       };
86671     } catch (std::exception& e) {
86672       {
86673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86674       };
86675     } catch (Dali::DaliException e) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86678       };
86679     } catch (...) {
86680       {
86681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86682       };
86683     }
86684   }
86685
86686   jresult = (void *)result;
86687   return jresult;
86688 }
86689
86690
86691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86692   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86693
86694   arg1 = (Dali::Toolkit::Slider *)jarg1;
86695   {
86696     try {
86697       delete arg1;
86698     } catch (std::out_of_range& e) {
86699       {
86700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86701       };
86702     } catch (std::exception& e) {
86703       {
86704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86705       };
86706     } catch (Dali::DaliException e) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86709       };
86710     } catch (...) {
86711       {
86712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86713       };
86714     }
86715   }
86716
86717 }
86718
86719
86720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86721   void * jresult ;
86722   Dali::BaseHandle arg1 ;
86723   Dali::BaseHandle *argp1 ;
86724   Dali::Toolkit::Slider result;
86725
86726   argp1 = (Dali::BaseHandle *)jarg1;
86727   if (!argp1) {
86728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86729     return 0;
86730   }
86731   arg1 = *argp1;
86732   {
86733     try {
86734       result = Dali::Toolkit::Slider::DownCast(arg1);
86735     } catch (std::out_of_range& e) {
86736       {
86737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86738       };
86739     } catch (std::exception& e) {
86740       {
86741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86742       };
86743     } catch (Dali::DaliException e) {
86744       {
86745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86746       };
86747     } catch (...) {
86748       {
86749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86750       };
86751     }
86752   }
86753
86754   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86755   return jresult;
86756 }
86757
86758
86759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86760   void * jresult ;
86761   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86762   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86763
86764   arg1 = (Dali::Toolkit::Slider *)jarg1;
86765   {
86766     try {
86767       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86768     } catch (std::out_of_range& e) {
86769       {
86770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86771       };
86772     } catch (std::exception& e) {
86773       {
86774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (Dali::DaliException e) {
86777       {
86778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786
86787   jresult = (void *)result;
86788   return jresult;
86789 }
86790
86791
86792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86793   void * jresult ;
86794   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86795   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86796
86797   arg1 = (Dali::Toolkit::Slider *)jarg1;
86798   {
86799     try {
86800       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86801     } catch (std::out_of_range& e) {
86802       {
86803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86804       };
86805     } catch (std::exception& e) {
86806       {
86807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86808       };
86809     } catch (Dali::DaliException e) {
86810       {
86811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86812       };
86813     } catch (...) {
86814       {
86815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86816       };
86817     }
86818   }
86819
86820   jresult = (void *)result;
86821   return jresult;
86822 }
86823
86824
86825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86826   void * jresult ;
86827   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86828   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86829
86830   arg1 = (Dali::Toolkit::Slider *)jarg1;
86831   {
86832     try {
86833       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86841       };
86842     } catch (Dali::DaliException e) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86845       };
86846     } catch (...) {
86847       {
86848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86849       };
86850     }
86851   }
86852
86853   jresult = (void *)result;
86854   return jresult;
86855 }
86856
86857
86858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86859   int jresult ;
86860   int result;
86861
86862   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86863   jresult = (int)result;
86864   return jresult;
86865 }
86866
86867
86868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86869   int jresult ;
86870   int result;
86871
86872   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86873   jresult = (int)result;
86874   return jresult;
86875 }
86876
86877
86878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86879   int jresult ;
86880   int result;
86881
86882   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86883   jresult = (int)result;
86884   return jresult;
86885 }
86886
86887
86888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86889   int jresult ;
86890   int result;
86891
86892   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86893   jresult = (int)result;
86894   return jresult;
86895 }
86896
86897
86898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86899   int result;
86900
86901   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86902
86903   return result;
86904 }
86905
86906
86907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86908   void * jresult ;
86909   Dali::Toolkit::VideoView::Property *result = 0 ;
86910
86911   {
86912     try {
86913       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86914     } catch (std::out_of_range& e) {
86915       {
86916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86917       };
86918     } catch (std::exception& e) {
86919       {
86920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86921       };
86922     } catch (Dali::DaliException e) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86925       };
86926     } catch (...) {
86927       {
86928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86929       };
86930     }
86931   }
86932
86933   jresult = (void *)result;
86934   return jresult;
86935 }
86936
86937
86938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86939   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86940
86941   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86942   {
86943     try {
86944       delete arg1;
86945     } catch (std::out_of_range& e) {
86946       {
86947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86948       };
86949     } catch (std::exception& e) {
86950       {
86951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86952       };
86953     } catch (Dali::DaliException e) {
86954       {
86955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86956       };
86957     } catch (...) {
86958       {
86959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86960       };
86961     }
86962   }
86963
86964 }
86965
86966
86967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86968   void * jresult ;
86969   Dali::Toolkit::VideoView result;
86970
86971   {
86972     try {
86973       result = Dali::Toolkit::VideoView::New();
86974     } catch (std::out_of_range& e) {
86975       {
86976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86977       };
86978     } catch (std::exception& e) {
86979       {
86980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86981       };
86982     } catch (Dali::DaliException e) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86985       };
86986     } catch (...) {
86987       {
86988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86989       };
86990     }
86991   }
86992
86993   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86994   return jresult;
86995 }
86996
86997
86998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86999   void * jresult ;
87000   std::string *arg1 = 0 ;
87001   Dali::Toolkit::VideoView result;
87002
87003   if (!jarg1) {
87004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87005     return 0;
87006   }
87007   std::string arg1_str(jarg1);
87008   arg1 = &arg1_str;
87009   {
87010     try {
87011       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87012     } catch (std::out_of_range& e) {
87013       {
87014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (std::exception& e) {
87017       {
87018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87019       };
87020     } catch (Dali::DaliException e) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87023       };
87024     } catch (...) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87027       };
87028     }
87029   }
87030
87031   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87032
87033   //argout typemap for const std::string&
87034
87035   return jresult;
87036 }
87037
87038
87039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87040   void * jresult ;
87041   Dali::Toolkit::VideoView *result = 0 ;
87042
87043   {
87044     try {
87045       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87046     } catch (std::out_of_range& e) {
87047       {
87048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87049       };
87050     } catch (std::exception& e) {
87051       {
87052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87053       };
87054     } catch (Dali::DaliException e) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87057       };
87058     } catch (...) {
87059       {
87060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87061       };
87062     }
87063   }
87064
87065   jresult = (void *)result;
87066   return jresult;
87067 }
87068
87069
87070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87071   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87072
87073   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87074   {
87075     try {
87076       delete arg1;
87077     } catch (std::out_of_range& e) {
87078       {
87079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87080       };
87081     } catch (std::exception& e) {
87082       {
87083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87084       };
87085     } catch (Dali::DaliException e) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87088       };
87089     } catch (...) {
87090       {
87091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87092       };
87093     }
87094   }
87095
87096 }
87097
87098
87099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87100   void * jresult ;
87101   Dali::Toolkit::VideoView *arg1 = 0 ;
87102   Dali::Toolkit::VideoView *result = 0 ;
87103
87104   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87105   if (!arg1) {
87106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87107     return 0;
87108   }
87109   {
87110     try {
87111       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87112     } catch (std::out_of_range& e) {
87113       {
87114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87115       };
87116     } catch (std::exception& e) {
87117       {
87118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87119       };
87120     } catch (Dali::DaliException e) {
87121       {
87122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87123       };
87124     } catch (...) {
87125       {
87126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87127       };
87128     }
87129   }
87130
87131   jresult = (void *)result;
87132   return jresult;
87133 }
87134
87135
87136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87137   void * jresult ;
87138   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87139   Dali::Toolkit::VideoView *arg2 = 0 ;
87140   Dali::Toolkit::VideoView *result = 0 ;
87141
87142   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87143   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87144   if (!arg2) {
87145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87146     return 0;
87147   }
87148   {
87149     try {
87150       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87151     } catch (std::out_of_range& e) {
87152       {
87153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87154       };
87155     } catch (std::exception& e) {
87156       {
87157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (Dali::DaliException e) {
87160       {
87161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87162       };
87163     } catch (...) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87166       };
87167     }
87168   }
87169
87170   jresult = (void *)result;
87171   return jresult;
87172 }
87173
87174
87175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87176   void * jresult ;
87177   Dali::BaseHandle arg1 ;
87178   Dali::BaseHandle *argp1 ;
87179   Dali::Toolkit::VideoView result;
87180
87181   argp1 = (Dali::BaseHandle *)jarg1;
87182   if (!argp1) {
87183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87184     return 0;
87185   }
87186   arg1 = *argp1;
87187   {
87188     try {
87189       result = Dali::Toolkit::VideoView::DownCast(arg1);
87190     } catch (std::out_of_range& e) {
87191       {
87192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87193       };
87194     } catch (std::exception& e) {
87195       {
87196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87197       };
87198     } catch (Dali::DaliException e) {
87199       {
87200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87201       };
87202     } catch (...) {
87203       {
87204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87205       };
87206     }
87207   }
87208
87209   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87210   return jresult;
87211 }
87212
87213
87214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87215   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87216
87217   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87218   {
87219     try {
87220       (arg1)->Play();
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (Dali::DaliException e) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87232       };
87233     } catch (...) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87236       };
87237     }
87238   }
87239
87240 }
87241
87242
87243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87244   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87245
87246   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87247   {
87248     try {
87249       (arg1)->Pause();
87250     } catch (std::out_of_range& e) {
87251       {
87252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87253       };
87254     } catch (std::exception& e) {
87255       {
87256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87257       };
87258     } catch (Dali::DaliException e) {
87259       {
87260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87261       };
87262     } catch (...) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87265       };
87266     }
87267   }
87268
87269 }
87270
87271
87272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87273   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87274
87275   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87276   {
87277     try {
87278       (arg1)->Stop();
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87286       };
87287     } catch (Dali::DaliException e) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87290       };
87291     } catch (...) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87294       };
87295     }
87296   }
87297
87298 }
87299
87300
87301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87302   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87303   int arg2 ;
87304
87305   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87306   arg2 = (int)jarg2;
87307   {
87308     try {
87309       (arg1)->Forward(arg2);
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87317       };
87318     } catch (Dali::DaliException e) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87321       };
87322     } catch (...) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87325       };
87326     }
87327   }
87328
87329 }
87330
87331
87332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87333   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87334   int arg2 ;
87335
87336   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87337   arg2 = (int)jarg2;
87338   {
87339     try {
87340       (arg1)->Backward(arg2);
87341     } catch (std::out_of_range& e) {
87342       {
87343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87344       };
87345     } catch (std::exception& e) {
87346       {
87347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87348       };
87349     } catch (Dali::DaliException e) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87352       };
87353     } catch (...) {
87354       {
87355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87356       };
87357     }
87358   }
87359
87360 }
87361
87362
87363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87364   void * jresult ;
87365   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87366   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87367
87368   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87369   {
87370     try {
87371       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87372     } catch (std::out_of_range& e) {
87373       {
87374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87375       };
87376     } catch (std::exception& e) {
87377       {
87378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87379       };
87380     } catch (Dali::DaliException e) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87383       };
87384     } catch (...) {
87385       {
87386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87387       };
87388     }
87389   }
87390
87391   jresult = (void *)result;
87392   return jresult;
87393 }
87394
87395
87396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87397   int jresult ;
87398   int result;
87399
87400   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87401   jresult = (int)result;
87402   return jresult;
87403 }
87404
87405
87406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87407   int jresult ;
87408   int result;
87409
87410   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87411   jresult = (int)result;
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87417   int jresult ;
87418   int result;
87419
87420   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87421   jresult = (int)result;
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87427   int jresult ;
87428   int result;
87429
87430   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87431   jresult = (int)result;
87432   return jresult;
87433 }
87434
87435
87436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87437   int jresult ;
87438   int result;
87439
87440   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87441   jresult = (int)result;
87442   return jresult;
87443 }
87444
87445
87446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87447   int jresult ;
87448   int result;
87449
87450   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87451   jresult = (int)result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87457   int jresult ;
87458   int result;
87459
87460   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87461   jresult = (int)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87467   int jresult ;
87468   int result;
87469
87470   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87471   jresult = (int)result;
87472   return jresult;
87473 }
87474
87475
87476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87477   int jresult ;
87478   int result;
87479
87480   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87481   jresult = (int)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87487   int jresult ;
87488   int result;
87489
87490   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87491   jresult = (int)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87497   int jresult ;
87498   int result;
87499
87500   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87501   jresult = (int)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87507   int jresult ;
87508   int result;
87509
87510   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87511   jresult = (int)result;
87512   return jresult;
87513 }
87514
87515
87516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87517   int jresult ;
87518   int result;
87519
87520   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87521   jresult = (int)result;
87522   return jresult;
87523 }
87524
87525
87526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87527   int jresult ;
87528   int result;
87529
87530   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87531   jresult = (int)result;
87532   return jresult;
87533 }
87534
87535
87536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87537   int jresult ;
87538   int result;
87539
87540   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87541   jresult = (int)result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87547   int jresult ;
87548   int result;
87549
87550   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87551   jresult = (int)result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87557   int jresult ;
87558   int result;
87559
87560   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87561   jresult = (int)result;
87562   return jresult;
87563 }
87564
87565
87566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87567   int jresult ;
87568   int result;
87569
87570   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87571   jresult = (int)result;
87572   return jresult;
87573 }
87574
87575
87576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87577   int jresult ;
87578   int result;
87579
87580   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87581   jresult = (int)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87587   int jresult ;
87588   int result;
87589
87590   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87591   jresult = (int)result;
87592   return jresult;
87593 }
87594
87595
87596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87597   int jresult ;
87598   int result;
87599
87600   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87601   jresult = (int)result;
87602   return jresult;
87603 }
87604
87605
87606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87607   void * jresult ;
87608   Dali::Toolkit::Popup::Property *result = 0 ;
87609
87610   {
87611     try {
87612       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87613     } catch (std::out_of_range& e) {
87614       {
87615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87616       };
87617     } catch (std::exception& e) {
87618       {
87619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87620       };
87621     } catch (Dali::DaliException e) {
87622       {
87623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87624       };
87625     } catch (...) {
87626       {
87627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87628       };
87629     }
87630   }
87631
87632   jresult = (void *)result;
87633   return jresult;
87634 }
87635
87636
87637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87638   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87639
87640   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87641   {
87642     try {
87643       delete arg1;
87644     } catch (std::out_of_range& e) {
87645       {
87646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87647       };
87648     } catch (std::exception& e) {
87649       {
87650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87651       };
87652     } catch (Dali::DaliException e) {
87653       {
87654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87655       };
87656     } catch (...) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87659       };
87660     }
87661   }
87662
87663 }
87664
87665
87666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87667   void * jresult ;
87668   Dali::Toolkit::Popup *result = 0 ;
87669
87670   {
87671     try {
87672       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87673     } catch (std::out_of_range& e) {
87674       {
87675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87676       };
87677     } catch (std::exception& e) {
87678       {
87679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87680       };
87681     } catch (Dali::DaliException e) {
87682       {
87683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87684       };
87685     } catch (...) {
87686       {
87687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87688       };
87689     }
87690   }
87691
87692   jresult = (void *)result;
87693   return jresult;
87694 }
87695
87696
87697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87698   void * jresult ;
87699   Dali::Toolkit::Popup result;
87700
87701   {
87702     try {
87703       result = Dali::Toolkit::Popup::New();
87704     } catch (std::out_of_range& e) {
87705       {
87706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87707       };
87708     } catch (std::exception& e) {
87709       {
87710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87711       };
87712     } catch (Dali::DaliException e) {
87713       {
87714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87715       };
87716     } catch (...) {
87717       {
87718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87719       };
87720     }
87721   }
87722
87723   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87724   return jresult;
87725 }
87726
87727
87728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87729   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87730
87731   arg1 = (Dali::Toolkit::Popup *)jarg1;
87732   {
87733     try {
87734       delete arg1;
87735     } catch (std::out_of_range& e) {
87736       {
87737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87738       };
87739     } catch (std::exception& e) {
87740       {
87741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87742       };
87743     } catch (Dali::DaliException e) {
87744       {
87745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87746       };
87747     } catch (...) {
87748       {
87749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87750       };
87751     }
87752   }
87753
87754 }
87755
87756
87757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87758   void * jresult ;
87759   Dali::Toolkit::Popup *arg1 = 0 ;
87760   Dali::Toolkit::Popup *result = 0 ;
87761
87762   arg1 = (Dali::Toolkit::Popup *)jarg1;
87763   if (!arg1) {
87764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87765     return 0;
87766   }
87767   {
87768     try {
87769       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87770     } catch (std::out_of_range& e) {
87771       {
87772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87773       };
87774     } catch (std::exception& e) {
87775       {
87776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87777       };
87778     } catch (Dali::DaliException e) {
87779       {
87780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87781       };
87782     } catch (...) {
87783       {
87784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87785       };
87786     }
87787   }
87788
87789   jresult = (void *)result;
87790   return jresult;
87791 }
87792
87793
87794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87795   void * jresult ;
87796   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87797   Dali::Toolkit::Popup *arg2 = 0 ;
87798   Dali::Toolkit::Popup *result = 0 ;
87799
87800   arg1 = (Dali::Toolkit::Popup *)jarg1;
87801   arg2 = (Dali::Toolkit::Popup *)jarg2;
87802   if (!arg2) {
87803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87804     return 0;
87805   }
87806   {
87807     try {
87808       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87809     } catch (std::out_of_range& e) {
87810       {
87811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87812       };
87813     } catch (std::exception& e) {
87814       {
87815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87816       };
87817     } catch (Dali::DaliException e) {
87818       {
87819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87824       };
87825     }
87826   }
87827
87828   jresult = (void *)result;
87829   return jresult;
87830 }
87831
87832
87833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87834   void * jresult ;
87835   Dali::BaseHandle arg1 ;
87836   Dali::BaseHandle *argp1 ;
87837   Dali::Toolkit::Popup result;
87838
87839   argp1 = (Dali::BaseHandle *)jarg1;
87840   if (!argp1) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87842     return 0;
87843   }
87844   arg1 = *argp1;
87845   {
87846     try {
87847       result = Dali::Toolkit::Popup::DownCast(arg1);
87848     } catch (std::out_of_range& e) {
87849       {
87850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (std::exception& e) {
87853       {
87854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87855       };
87856     } catch (Dali::DaliException e) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87859       };
87860     } catch (...) {
87861       {
87862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87863       };
87864     }
87865   }
87866
87867   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87873   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87874   Dali::Actor arg2 ;
87875   Dali::Actor *argp2 ;
87876
87877   arg1 = (Dali::Toolkit::Popup *)jarg1;
87878   argp2 = (Dali::Actor *)jarg2;
87879   if (!argp2) {
87880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87881     return ;
87882   }
87883   arg2 = *argp2;
87884   {
87885     try {
87886       (arg1)->SetTitle(arg2);
87887     } catch (std::out_of_range& e) {
87888       {
87889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87890       };
87891     } catch (std::exception& e) {
87892       {
87893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87894       };
87895     } catch (Dali::DaliException e) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87898       };
87899     } catch (...) {
87900       {
87901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87902       };
87903     }
87904   }
87905
87906 }
87907
87908
87909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87910   void * jresult ;
87911   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87912   Dali::Actor result;
87913
87914   arg1 = (Dali::Toolkit::Popup *)jarg1;
87915   {
87916     try {
87917       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87918     } catch (std::out_of_range& e) {
87919       {
87920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87921       };
87922     } catch (std::exception& e) {
87923       {
87924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87925       };
87926     } catch (Dali::DaliException e) {
87927       {
87928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87929       };
87930     } catch (...) {
87931       {
87932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87933       };
87934     }
87935   }
87936
87937   jresult = new Dali::Actor((const Dali::Actor &)result);
87938   return jresult;
87939 }
87940
87941
87942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87943   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87944   Dali::Actor arg2 ;
87945   Dali::Actor *argp2 ;
87946
87947   arg1 = (Dali::Toolkit::Popup *)jarg1;
87948   argp2 = (Dali::Actor *)jarg2;
87949   if (!argp2) {
87950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87951     return ;
87952   }
87953   arg2 = *argp2;
87954   {
87955     try {
87956       (arg1)->SetContent(arg2);
87957     } catch (std::out_of_range& e) {
87958       {
87959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87960       };
87961     } catch (std::exception& e) {
87962       {
87963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87964       };
87965     } catch (Dali::DaliException e) {
87966       {
87967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87968       };
87969     } catch (...) {
87970       {
87971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87972       };
87973     }
87974   }
87975
87976 }
87977
87978
87979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87980   void * jresult ;
87981   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87982   Dali::Actor result;
87983
87984   arg1 = (Dali::Toolkit::Popup *)jarg1;
87985   {
87986     try {
87987       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87988     } catch (std::out_of_range& e) {
87989       {
87990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (std::exception& e) {
87993       {
87994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87995       };
87996     } catch (Dali::DaliException e) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87999       };
88000     } catch (...) {
88001       {
88002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88003       };
88004     }
88005   }
88006
88007   jresult = new Dali::Actor((const Dali::Actor &)result);
88008   return jresult;
88009 }
88010
88011
88012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88013   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88014   Dali::Actor arg2 ;
88015   Dali::Actor *argp2 ;
88016
88017   arg1 = (Dali::Toolkit::Popup *)jarg1;
88018   argp2 = (Dali::Actor *)jarg2;
88019   if (!argp2) {
88020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88021     return ;
88022   }
88023   arg2 = *argp2;
88024   {
88025     try {
88026       (arg1)->SetFooter(arg2);
88027     } catch (std::out_of_range& e) {
88028       {
88029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88030       };
88031     } catch (std::exception& e) {
88032       {
88033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88034       };
88035     } catch (Dali::DaliException e) {
88036       {
88037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88038       };
88039     } catch (...) {
88040       {
88041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88042       };
88043     }
88044   }
88045
88046 }
88047
88048
88049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88050   void * jresult ;
88051   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88052   Dali::Actor result;
88053
88054   arg1 = (Dali::Toolkit::Popup *)jarg1;
88055   {
88056     try {
88057       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88058     } catch (std::out_of_range& e) {
88059       {
88060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88061       };
88062     } catch (std::exception& e) {
88063       {
88064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88065       };
88066     } catch (Dali::DaliException e) {
88067       {
88068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88069       };
88070     } catch (...) {
88071       {
88072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88073       };
88074     }
88075   }
88076
88077   jresult = new Dali::Actor((const Dali::Actor &)result);
88078   return jresult;
88079 }
88080
88081
88082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88083   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88084   Dali::Toolkit::Popup::DisplayState arg2 ;
88085
88086   arg1 = (Dali::Toolkit::Popup *)jarg1;
88087   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88088   {
88089     try {
88090       (arg1)->SetDisplayState(arg2);
88091     } catch (std::out_of_range& e) {
88092       {
88093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88094       };
88095     } catch (std::exception& e) {
88096       {
88097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88098       };
88099     } catch (Dali::DaliException e) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88102       };
88103     } catch (...) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88106       };
88107     }
88108   }
88109
88110 }
88111
88112
88113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88114   int jresult ;
88115   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88116   Dali::Toolkit::Popup::DisplayState result;
88117
88118   arg1 = (Dali::Toolkit::Popup *)jarg1;
88119   {
88120     try {
88121       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (Dali::DaliException e) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88137       };
88138     }
88139   }
88140
88141   jresult = (int)result;
88142   return jresult;
88143 }
88144
88145
88146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88147   void * jresult ;
88148   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88149   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88150
88151   arg1 = (Dali::Toolkit::Popup *)jarg1;
88152   {
88153     try {
88154       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88155     } catch (std::out_of_range& e) {
88156       {
88157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88158       };
88159     } catch (std::exception& e) {
88160       {
88161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88162       };
88163     } catch (Dali::DaliException e) {
88164       {
88165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88166       };
88167     } catch (...) {
88168       {
88169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88170       };
88171     }
88172   }
88173
88174   jresult = (void *)result;
88175   return jresult;
88176 }
88177
88178
88179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88180   void * jresult ;
88181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88182   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88183
88184   arg1 = (Dali::Toolkit::Popup *)jarg1;
88185   {
88186     try {
88187       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88188     } catch (std::out_of_range& e) {
88189       {
88190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88191       };
88192     } catch (std::exception& e) {
88193       {
88194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88195       };
88196     } catch (Dali::DaliException e) {
88197       {
88198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88199       };
88200     } catch (...) {
88201       {
88202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88203       };
88204     }
88205   }
88206
88207   jresult = (void *)result;
88208   return jresult;
88209 }
88210
88211
88212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88213   void * jresult ;
88214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88215   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88216
88217   arg1 = (Dali::Toolkit::Popup *)jarg1;
88218   {
88219     try {
88220       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88221     } catch (std::out_of_range& e) {
88222       {
88223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88224       };
88225     } catch (std::exception& e) {
88226       {
88227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88228       };
88229     } catch (Dali::DaliException e) {
88230       {
88231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88232       };
88233     } catch (...) {
88234       {
88235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88236       };
88237     }
88238   }
88239
88240   jresult = (void *)result;
88241   return jresult;
88242 }
88243
88244
88245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88246   void * jresult ;
88247   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88248   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88249
88250   arg1 = (Dali::Toolkit::Popup *)jarg1;
88251   {
88252     try {
88253       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88254     } catch (std::out_of_range& e) {
88255       {
88256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88257       };
88258     } catch (std::exception& e) {
88259       {
88260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88261       };
88262     } catch (Dali::DaliException e) {
88263       {
88264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88265       };
88266     } catch (...) {
88267       {
88268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88269       };
88270     }
88271   }
88272
88273   jresult = (void *)result;
88274   return jresult;
88275 }
88276
88277
88278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88279   void * jresult ;
88280   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88281   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88282
88283   arg1 = (Dali::Toolkit::Popup *)jarg1;
88284   {
88285     try {
88286       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88287     } catch (std::out_of_range& e) {
88288       {
88289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88290       };
88291     } catch (std::exception& e) {
88292       {
88293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88294       };
88295     } catch (Dali::DaliException e) {
88296       {
88297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88298       };
88299     } catch (...) {
88300       {
88301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88302       };
88303     }
88304   }
88305
88306   jresult = (void *)result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88312   int jresult ;
88313   int result;
88314
88315   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88316   jresult = (int)result;
88317   return jresult;
88318 }
88319
88320
88321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88322   int jresult ;
88323   int result;
88324
88325   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88326   jresult = (int)result;
88327   return jresult;
88328 }
88329
88330
88331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88332   int jresult ;
88333   int result;
88334
88335   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88336   jresult = (int)result;
88337   return jresult;
88338 }
88339
88340
88341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88342   int jresult ;
88343   int result;
88344
88345   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88346   jresult = (int)result;
88347   return jresult;
88348 }
88349
88350
88351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88352   int jresult ;
88353   int result;
88354
88355   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88356   jresult = (int)result;
88357   return jresult;
88358 }
88359
88360
88361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88362   int jresult ;
88363   int result;
88364
88365   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88366   jresult = (int)result;
88367   return jresult;
88368 }
88369
88370
88371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88372   int jresult ;
88373   int result;
88374
88375   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88376   jresult = (int)result;
88377   return jresult;
88378 }
88379
88380
88381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88382   int jresult ;
88383   int result;
88384
88385   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88386   jresult = (int)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88392   int jresult ;
88393   int result;
88394
88395   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88396   jresult = (int)result;
88397   return jresult;
88398 }
88399
88400
88401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88402   void * jresult ;
88403   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88404
88405   {
88406     try {
88407       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88408     } catch (std::out_of_range& e) {
88409       {
88410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88411       };
88412     } catch (std::exception& e) {
88413       {
88414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88415       };
88416     } catch (Dali::DaliException e) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88419       };
88420     } catch (...) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88423       };
88424     }
88425   }
88426
88427   jresult = (void *)result;
88428   return jresult;
88429 }
88430
88431
88432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88433   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88434
88435   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88436   {
88437     try {
88438       delete arg1;
88439     } catch (std::out_of_range& e) {
88440       {
88441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88442       };
88443     } catch (std::exception& e) {
88444       {
88445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88446       };
88447     } catch (Dali::DaliException e) {
88448       {
88449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88450       };
88451     } catch (...) {
88452       {
88453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88454       };
88455     }
88456   }
88457
88458 }
88459
88460
88461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88462   void * jresult ;
88463   Dali::Toolkit::ProgressBar result;
88464
88465   {
88466     try {
88467       result = Dali::Toolkit::ProgressBar::New();
88468     } catch (std::out_of_range& e) {
88469       {
88470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88471       };
88472     } catch (std::exception& e) {
88473       {
88474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88475       };
88476     } catch (Dali::DaliException e) {
88477       {
88478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88479       };
88480     } catch (...) {
88481       {
88482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88483       };
88484     }
88485   }
88486
88487   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88488   return jresult;
88489 }
88490
88491
88492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88493   void * jresult ;
88494   Dali::Toolkit::ProgressBar *result = 0 ;
88495
88496   {
88497     try {
88498       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88499     } catch (std::out_of_range& e) {
88500       {
88501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88502       };
88503     } catch (std::exception& e) {
88504       {
88505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88506       };
88507     } catch (Dali::DaliException e) {
88508       {
88509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88510       };
88511     } catch (...) {
88512       {
88513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88514       };
88515     }
88516   }
88517
88518   jresult = (void *)result;
88519   return jresult;
88520 }
88521
88522
88523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88524   void * jresult ;
88525   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88526   Dali::Toolkit::ProgressBar *result = 0 ;
88527
88528   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88529   if (!arg1) {
88530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88531     return 0;
88532   }
88533   {
88534     try {
88535       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88536     } catch (std::out_of_range& e) {
88537       {
88538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88539       };
88540     } catch (std::exception& e) {
88541       {
88542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88543       };
88544     } catch (Dali::DaliException e) {
88545       {
88546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88547       };
88548     } catch (...) {
88549       {
88550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88551       };
88552     }
88553   }
88554
88555   jresult = (void *)result;
88556   return jresult;
88557 }
88558
88559
88560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88561   void * jresult ;
88562   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88563   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88564   Dali::Toolkit::ProgressBar *result = 0 ;
88565
88566   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88567   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88568   if (!arg2) {
88569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88570     return 0;
88571   }
88572   {
88573     try {
88574       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88575     } catch (std::out_of_range& e) {
88576       {
88577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88578       };
88579     } catch (std::exception& e) {
88580       {
88581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88582       };
88583     } catch (Dali::DaliException e) {
88584       {
88585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88586       };
88587     } catch (...) {
88588       {
88589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88590       };
88591     }
88592   }
88593
88594   jresult = (void *)result;
88595   return jresult;
88596 }
88597
88598
88599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88600   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88601
88602   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88603   {
88604     try {
88605       delete arg1;
88606     } catch (std::out_of_range& e) {
88607       {
88608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88609       };
88610     } catch (std::exception& e) {
88611       {
88612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88613       };
88614     } catch (Dali::DaliException e) {
88615       {
88616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88617       };
88618     } catch (...) {
88619       {
88620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88621       };
88622     }
88623   }
88624
88625 }
88626
88627
88628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88629   void * jresult ;
88630   Dali::BaseHandle arg1 ;
88631   Dali::BaseHandle *argp1 ;
88632   Dali::Toolkit::ProgressBar result;
88633
88634   argp1 = (Dali::BaseHandle *)jarg1;
88635   if (!argp1) {
88636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88637     return 0;
88638   }
88639   arg1 = *argp1;
88640   {
88641     try {
88642       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88643     } catch (std::out_of_range& e) {
88644       {
88645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88646       };
88647     } catch (std::exception& e) {
88648       {
88649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (Dali::DaliException e) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88654       };
88655     } catch (...) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88658       };
88659     }
88660   }
88661
88662   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88663   return jresult;
88664 }
88665
88666
88667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88668   void * jresult ;
88669   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88670   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88671
88672   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88673   {
88674     try {
88675       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88676     } catch (std::out_of_range& e) {
88677       {
88678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88679       };
88680     } catch (std::exception& e) {
88681       {
88682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88683       };
88684     } catch (Dali::DaliException e) {
88685       {
88686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88687       };
88688     } catch (...) {
88689       {
88690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88691       };
88692     }
88693   }
88694
88695   jresult = (void *)result;
88696   return jresult;
88697 }
88698
88699
88700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88701   void * jresult ;
88702   Dali::Toolkit::GaussianBlurView *result = 0 ;
88703
88704   {
88705     try {
88706       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88707     } catch (std::out_of_range& e) {
88708       {
88709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88710       };
88711     } catch (std::exception& e) {
88712       {
88713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88714       };
88715     } catch (Dali::DaliException e) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88718       };
88719     } catch (...) {
88720       {
88721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88722       };
88723     }
88724   }
88725
88726   jresult = (void *)result;
88727   return jresult;
88728 }
88729
88730
88731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88732   void * jresult ;
88733   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88734   Dali::Toolkit::GaussianBlurView *result = 0 ;
88735
88736   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88737   if (!arg1) {
88738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88739     return 0;
88740   }
88741   {
88742     try {
88743       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88744     } catch (std::out_of_range& e) {
88745       {
88746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (std::exception& e) {
88749       {
88750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (Dali::DaliException e) {
88753       {
88754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88759       };
88760     }
88761   }
88762
88763   jresult = (void *)result;
88764   return jresult;
88765 }
88766
88767
88768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88769   void * jresult ;
88770   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88771   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88772   Dali::Toolkit::GaussianBlurView *result = 0 ;
88773
88774   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88775   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88776   if (!arg2) {
88777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88778     return 0;
88779   }
88780   {
88781     try {
88782       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88783     } catch (std::out_of_range& e) {
88784       {
88785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88786       };
88787     } catch (std::exception& e) {
88788       {
88789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88790       };
88791     } catch (Dali::DaliException e) {
88792       {
88793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88794       };
88795     } catch (...) {
88796       {
88797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88798       };
88799     }
88800   }
88801
88802   jresult = (void *)result;
88803   return jresult;
88804 }
88805
88806
88807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88808   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88809
88810   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88811   {
88812     try {
88813       delete arg1;
88814     } catch (std::out_of_range& e) {
88815       {
88816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88817       };
88818     } catch (std::exception& e) {
88819       {
88820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88821       };
88822     } catch (Dali::DaliException e) {
88823       {
88824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88825       };
88826     } catch (...) {
88827       {
88828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88829       };
88830     }
88831   }
88832
88833 }
88834
88835
88836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88837   void * jresult ;
88838   Dali::BaseHandle arg1 ;
88839   Dali::BaseHandle *argp1 ;
88840   Dali::Toolkit::GaussianBlurView result;
88841
88842   argp1 = (Dali::BaseHandle *)jarg1;
88843   if (!argp1) {
88844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88845     return 0;
88846   }
88847   arg1 = *argp1;
88848   {
88849     try {
88850       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88851     } catch (std::out_of_range& e) {
88852       {
88853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88854       };
88855     } catch (std::exception& e) {
88856       {
88857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88858       };
88859     } catch (Dali::DaliException e) {
88860       {
88861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88862       };
88863     } catch (...) {
88864       {
88865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88866       };
88867     }
88868   }
88869
88870   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88871   return jresult;
88872 }
88873
88874
88875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88876   void * jresult ;
88877   Dali::Toolkit::GaussianBlurView result;
88878
88879   {
88880     try {
88881       result = Dali::Toolkit::GaussianBlurView::New();
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 = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88902   return jresult;
88903 }
88904
88905
88906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88907   void * jresult ;
88908   unsigned int arg1 ;
88909   float arg2 ;
88910   Dali::Pixel::Format arg3 ;
88911   float arg4 ;
88912   float arg5 ;
88913   bool arg6 ;
88914   Dali::Toolkit::GaussianBlurView result;
88915
88916   arg1 = (unsigned int)jarg1;
88917   arg2 = (float)jarg2;
88918   arg3 = (Dali::Pixel::Format)jarg3;
88919   arg4 = (float)jarg4;
88920   arg5 = (float)jarg5;
88921   arg6 = jarg6 ? true : false;
88922   {
88923     try {
88924       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88925     } catch (std::out_of_range& e) {
88926       {
88927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88928       };
88929     } catch (std::exception& e) {
88930       {
88931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88932       };
88933     } catch (Dali::DaliException e) {
88934       {
88935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88936       };
88937     } catch (...) {
88938       {
88939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88940       };
88941     }
88942   }
88943
88944   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88945   return jresult;
88946 }
88947
88948
88949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88950   void * jresult ;
88951   unsigned int arg1 ;
88952   float arg2 ;
88953   Dali::Pixel::Format arg3 ;
88954   float arg4 ;
88955   float arg5 ;
88956   Dali::Toolkit::GaussianBlurView result;
88957
88958   arg1 = (unsigned int)jarg1;
88959   arg2 = (float)jarg2;
88960   arg3 = (Dali::Pixel::Format)jarg3;
88961   arg4 = (float)jarg4;
88962   arg5 = (float)jarg5;
88963   {
88964     try {
88965       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88966     } catch (std::out_of_range& e) {
88967       {
88968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88969       };
88970     } catch (std::exception& e) {
88971       {
88972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88973       };
88974     } catch (Dali::DaliException e) {
88975       {
88976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88977       };
88978     } catch (...) {
88979       {
88980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88981       };
88982     }
88983   }
88984
88985   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88986   return jresult;
88987 }
88988
88989
88990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88991   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88992   Dali::Actor arg2 ;
88993   Dali::Actor *argp2 ;
88994
88995   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88996   argp2 = (Dali::Actor *)jarg2;
88997   if (!argp2) {
88998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88999     return ;
89000   }
89001   arg2 = *argp2;
89002   {
89003     try {
89004       (arg1)->Add(arg2);
89005     } catch (std::out_of_range& e) {
89006       {
89007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89008       };
89009     } catch (std::exception& e) {
89010       {
89011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89012       };
89013     } catch (Dali::DaliException e) {
89014       {
89015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89016       };
89017     } catch (...) {
89018       {
89019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89020       };
89021     }
89022   }
89023
89024 }
89025
89026
89027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89028   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89029   Dali::Actor arg2 ;
89030   Dali::Actor *argp2 ;
89031
89032   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89033   argp2 = (Dali::Actor *)jarg2;
89034   if (!argp2) {
89035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89036     return ;
89037   }
89038   arg2 = *argp2;
89039   {
89040     try {
89041       (arg1)->Remove(arg2);
89042     } catch (std::out_of_range& e) {
89043       {
89044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89045       };
89046     } catch (std::exception& e) {
89047       {
89048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89049       };
89050     } catch (Dali::DaliException e) {
89051       {
89052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89053       };
89054     } catch (...) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89057       };
89058     }
89059   }
89060
89061 }
89062
89063
89064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89065   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89066
89067   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89068   {
89069     try {
89070       (arg1)->Activate();
89071     } catch (std::out_of_range& e) {
89072       {
89073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89074       };
89075     } catch (std::exception& e) {
89076       {
89077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89078       };
89079     } catch (Dali::DaliException e) {
89080       {
89081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89086       };
89087     }
89088   }
89089
89090 }
89091
89092
89093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89094   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89095
89096   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89097   {
89098     try {
89099       (arg1)->ActivateOnce();
89100     } catch (std::out_of_range& e) {
89101       {
89102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89103       };
89104     } catch (std::exception& e) {
89105       {
89106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89107       };
89108     } catch (Dali::DaliException e) {
89109       {
89110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89111       };
89112     } catch (...) {
89113       {
89114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89115       };
89116     }
89117   }
89118
89119 }
89120
89121
89122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89123   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89124
89125   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89126   {
89127     try {
89128       (arg1)->Deactivate();
89129     } catch (std::out_of_range& e) {
89130       {
89131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89132       };
89133     } catch (std::exception& e) {
89134       {
89135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89136       };
89137     } catch (Dali::DaliException e) {
89138       {
89139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89140       };
89141     } catch (...) {
89142       {
89143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89144       };
89145     }
89146   }
89147
89148 }
89149
89150
89151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89152   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89153   Dali::Image arg2 ;
89154   Dali::FrameBufferImage arg3 ;
89155   Dali::Image *argp2 ;
89156   Dali::FrameBufferImage *argp3 ;
89157
89158   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89159   argp2 = (Dali::Image *)jarg2;
89160   if (!argp2) {
89161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89162     return ;
89163   }
89164   arg2 = *argp2;
89165   argp3 = (Dali::FrameBufferImage *)jarg3;
89166   if (!argp3) {
89167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89168     return ;
89169   }
89170   arg3 = *argp3;
89171   {
89172     try {
89173       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89181       };
89182     } catch (Dali::DaliException e) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89185       };
89186     } catch (...) {
89187       {
89188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89189       };
89190     }
89191   }
89192
89193 }
89194
89195
89196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89197   int jresult ;
89198   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89199   Dali::Property::Index result;
89200
89201   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89202   {
89203     try {
89204       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89205     } catch (std::out_of_range& e) {
89206       {
89207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89208       };
89209     } catch (std::exception& e) {
89210       {
89211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89212       };
89213     } catch (Dali::DaliException e) {
89214       {
89215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89216       };
89217     } catch (...) {
89218       {
89219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89220       };
89221     }
89222   }
89223
89224   jresult = result;
89225   return jresult;
89226 }
89227
89228
89229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89230   void * jresult ;
89231   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89232   Dali::FrameBufferImage result;
89233
89234   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89235   {
89236     try {
89237       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89238     } catch (std::out_of_range& e) {
89239       {
89240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89241       };
89242     } catch (std::exception& e) {
89243       {
89244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89245       };
89246     } catch (Dali::DaliException e) {
89247       {
89248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89249       };
89250     } catch (...) {
89251       {
89252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89253       };
89254     }
89255   }
89256
89257   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89258   return jresult;
89259 }
89260
89261
89262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89263   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89264   Dali::Vector4 *arg2 = 0 ;
89265
89266   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89267   arg2 = (Dali::Vector4 *)jarg2;
89268   if (!arg2) {
89269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89270     return ;
89271   }
89272   {
89273     try {
89274       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89275     } catch (std::out_of_range& e) {
89276       {
89277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89278       };
89279     } catch (std::exception& e) {
89280       {
89281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89282       };
89283     } catch (Dali::DaliException e) {
89284       {
89285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89286       };
89287     } catch (...) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89290       };
89291     }
89292   }
89293
89294 }
89295
89296
89297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89298   void * jresult ;
89299   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89300   Dali::Vector4 result;
89301
89302   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89303   {
89304     try {
89305       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89306     } catch (std::out_of_range& e) {
89307       {
89308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89309       };
89310     } catch (std::exception& e) {
89311       {
89312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89313       };
89314     } catch (Dali::DaliException e) {
89315       {
89316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89317       };
89318     } catch (...) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89321       };
89322     }
89323   }
89324
89325   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89326   return jresult;
89327 }
89328
89329
89330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89331   void * jresult ;
89332   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89333   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89334
89335   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89336   {
89337     try {
89338       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89339     } catch (std::out_of_range& e) {
89340       {
89341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89342       };
89343     } catch (std::exception& e) {
89344       {
89345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89346       };
89347     } catch (Dali::DaliException e) {
89348       {
89349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89350       };
89351     } catch (...) {
89352       {
89353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89354       };
89355     }
89356   }
89357
89358   jresult = (void *)result;
89359   return jresult;
89360 }
89361
89362
89363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89364   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89365
89366   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89367   {
89368     try {
89369       delete arg1;
89370     } catch (std::out_of_range& e) {
89371       {
89372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (std::exception& e) {
89375       {
89376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89377       };
89378     } catch (Dali::DaliException e) {
89379       {
89380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89381       };
89382     } catch (...) {
89383       {
89384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89385       };
89386     }
89387   }
89388
89389 }
89390
89391
89392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89393   unsigned int jresult ;
89394   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89395   unsigned int result;
89396
89397   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89398   {
89399     try {
89400       result = (unsigned int)(arg1)->GetNumberOfPages();
89401     } catch (std::out_of_range& e) {
89402       {
89403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89404       };
89405     } catch (std::exception& e) {
89406       {
89407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89408       };
89409     } catch (Dali::DaliException e) {
89410       {
89411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89412       };
89413     } catch (...) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89416       };
89417     }
89418   }
89419
89420   jresult = result;
89421   return jresult;
89422 }
89423
89424
89425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89426   void * jresult ;
89427   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89428   unsigned int arg2 ;
89429   Dali::Texture result;
89430
89431   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89432   arg2 = (unsigned int)jarg2;
89433   {
89434     try {
89435       result = (arg1)->NewPage(arg2);
89436     } catch (std::out_of_range& e) {
89437       {
89438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89439       };
89440     } catch (std::exception& e) {
89441       {
89442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89443       };
89444     } catch (Dali::DaliException e) {
89445       {
89446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89447       };
89448     } catch (...) {
89449       {
89450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89451       };
89452     }
89453   }
89454
89455   jresult = new Dali::Texture((const Dali::Texture &)result);
89456   return jresult;
89457 }
89458
89459
89460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89461   int jresult ;
89462   int result;
89463
89464   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89465   jresult = (int)result;
89466   return jresult;
89467 }
89468
89469
89470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89471   int jresult ;
89472   int result;
89473
89474   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89475   jresult = (int)result;
89476   return jresult;
89477 }
89478
89479
89480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89481   int jresult ;
89482   int result;
89483
89484   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89485   jresult = (int)result;
89486   return jresult;
89487 }
89488
89489
89490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89491   void * jresult ;
89492   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89493
89494   {
89495     try {
89496       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89497     } catch (std::out_of_range& e) {
89498       {
89499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89500       };
89501     } catch (std::exception& e) {
89502       {
89503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89504       };
89505     } catch (Dali::DaliException e) {
89506       {
89507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89508       };
89509     } catch (...) {
89510       {
89511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89512       };
89513     }
89514   }
89515
89516   jresult = (void *)result;
89517   return jresult;
89518 }
89519
89520
89521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89522   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89523
89524   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89525   {
89526     try {
89527       delete arg1;
89528     } catch (std::out_of_range& e) {
89529       {
89530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89531       };
89532     } catch (std::exception& e) {
89533       {
89534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89535       };
89536     } catch (Dali::DaliException e) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89543       };
89544     }
89545   }
89546
89547 }
89548
89549
89550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89551   void * jresult ;
89552   Dali::Toolkit::PageTurnView *result = 0 ;
89553
89554   {
89555     try {
89556       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89557     } catch (std::out_of_range& e) {
89558       {
89559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89560       };
89561     } catch (std::exception& e) {
89562       {
89563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89564       };
89565     } catch (Dali::DaliException e) {
89566       {
89567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89568       };
89569     } catch (...) {
89570       {
89571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89572       };
89573     }
89574   }
89575
89576   jresult = (void *)result;
89577   return jresult;
89578 }
89579
89580
89581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89582   void * jresult ;
89583   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89584   Dali::Toolkit::PageTurnView *result = 0 ;
89585
89586   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89587   if (!arg1) {
89588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89589     return 0;
89590   }
89591   {
89592     try {
89593       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89594     } catch (std::out_of_range& e) {
89595       {
89596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89597       };
89598     } catch (std::exception& e) {
89599       {
89600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (Dali::DaliException e) {
89603       {
89604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89605       };
89606     } catch (...) {
89607       {
89608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89609       };
89610     }
89611   }
89612
89613   jresult = (void *)result;
89614   return jresult;
89615 }
89616
89617
89618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89619   void * jresult ;
89620   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89621   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89622   Dali::Toolkit::PageTurnView *result = 0 ;
89623
89624   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89625   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89626   if (!arg2) {
89627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89628     return 0;
89629   }
89630   {
89631     try {
89632       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89633     } catch (std::out_of_range& e) {
89634       {
89635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89636       };
89637     } catch (std::exception& e) {
89638       {
89639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (Dali::DaliException e) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89644       };
89645     } catch (...) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89648       };
89649     }
89650   }
89651
89652   jresult = (void *)result;
89653   return jresult;
89654 }
89655
89656
89657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89658   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89659
89660   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89661   {
89662     try {
89663       delete arg1;
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89671       };
89672     } catch (Dali::DaliException e) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89675       };
89676     } catch (...) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89679       };
89680     }
89681   }
89682
89683 }
89684
89685
89686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89687   void * jresult ;
89688   Dali::BaseHandle arg1 ;
89689   Dali::BaseHandle *argp1 ;
89690   Dali::Toolkit::PageTurnView result;
89691
89692   argp1 = (Dali::BaseHandle *)jarg1;
89693   if (!argp1) {
89694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89695     return 0;
89696   }
89697   arg1 = *argp1;
89698   {
89699     try {
89700       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89701     } catch (std::out_of_range& e) {
89702       {
89703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89704       };
89705     } catch (std::exception& e) {
89706       {
89707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89708       };
89709     } catch (Dali::DaliException e) {
89710       {
89711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89712       };
89713     } catch (...) {
89714       {
89715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89716       };
89717     }
89718   }
89719
89720   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89721   return jresult;
89722 }
89723
89724
89725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89726   void * jresult ;
89727   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89728   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89729
89730   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89731   {
89732     try {
89733       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89734     } catch (std::out_of_range& e) {
89735       {
89736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (std::exception& e) {
89739       {
89740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89741       };
89742     } catch (Dali::DaliException e) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89745       };
89746     } catch (...) {
89747       {
89748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89749       };
89750     }
89751   }
89752
89753   jresult = (void *)result;
89754   return jresult;
89755 }
89756
89757
89758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89759   void * jresult ;
89760   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89761   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89762
89763   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89764   {
89765     try {
89766       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89774       };
89775     } catch (Dali::DaliException e) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89778       };
89779     } catch (...) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89782       };
89783     }
89784   }
89785
89786   jresult = (void *)result;
89787   return jresult;
89788 }
89789
89790
89791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89792   void * jresult ;
89793   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89794   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89795
89796   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89797   {
89798     try {
89799       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89800     } catch (std::out_of_range& e) {
89801       {
89802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89803       };
89804     } catch (std::exception& e) {
89805       {
89806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89807       };
89808     } catch (Dali::DaliException e) {
89809       {
89810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89815       };
89816     }
89817   }
89818
89819   jresult = (void *)result;
89820   return jresult;
89821 }
89822
89823
89824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89825   void * jresult ;
89826   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89827   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89828
89829   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89830   {
89831     try {
89832       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = (void *)result;
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89858   void * jresult ;
89859   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89860
89861   {
89862     try {
89863       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (Dali::DaliException e) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89879       };
89880     }
89881   }
89882
89883   jresult = (void *)result;
89884   return jresult;
89885 }
89886
89887
89888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89889   void * jresult ;
89890   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89891   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89892
89893   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89894   if (!arg1) {
89895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89896     return 0;
89897   }
89898   {
89899     try {
89900       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89901     } catch (std::out_of_range& e) {
89902       {
89903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89904       };
89905     } catch (std::exception& e) {
89906       {
89907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89908       };
89909     } catch (Dali::DaliException e) {
89910       {
89911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89912       };
89913     } catch (...) {
89914       {
89915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89916       };
89917     }
89918   }
89919
89920   jresult = (void *)result;
89921   return jresult;
89922 }
89923
89924
89925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89926   void * jresult ;
89927   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89928   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89929   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89930
89931   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89932   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89933   if (!arg2) {
89934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89935     return 0;
89936   }
89937   {
89938     try {
89939       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89940     } catch (std::out_of_range& e) {
89941       {
89942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89943       };
89944     } catch (std::exception& e) {
89945       {
89946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89947       };
89948     } catch (Dali::DaliException e) {
89949       {
89950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89951       };
89952     } catch (...) {
89953       {
89954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89955       };
89956     }
89957   }
89958
89959   jresult = (void *)result;
89960   return jresult;
89961 }
89962
89963
89964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89965   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89966
89967   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89968   {
89969     try {
89970       delete arg1;
89971     } catch (std::out_of_range& e) {
89972       {
89973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89974       };
89975     } catch (std::exception& e) {
89976       {
89977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89978       };
89979     } catch (Dali::DaliException e) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89982       };
89983     } catch (...) {
89984       {
89985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89986       };
89987     }
89988   }
89989
89990 }
89991
89992
89993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89994   void * jresult ;
89995   Dali::Toolkit::PageFactory *arg1 = 0 ;
89996   Dali::Vector2 *arg2 = 0 ;
89997   Dali::Toolkit::PageTurnLandscapeView result;
89998
89999   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90000   if (!arg1) {
90001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90002     return 0;
90003   }
90004   arg2 = (Dali::Vector2 *)jarg2;
90005   if (!arg2) {
90006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90007     return 0;
90008   }
90009   {
90010     try {
90011       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90012     } catch (std::out_of_range& e) {
90013       {
90014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90015       };
90016     } catch (std::exception& e) {
90017       {
90018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90019       };
90020     } catch (Dali::DaliException e) {
90021       {
90022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90023       };
90024     } catch (...) {
90025       {
90026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90027       };
90028     }
90029   }
90030
90031   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90032   return jresult;
90033 }
90034
90035
90036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90037   void * jresult ;
90038   Dali::BaseHandle arg1 ;
90039   Dali::BaseHandle *argp1 ;
90040   Dali::Toolkit::PageTurnLandscapeView result;
90041
90042   argp1 = (Dali::BaseHandle *)jarg1;
90043   if (!argp1) {
90044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90045     return 0;
90046   }
90047   arg1 = *argp1;
90048   {
90049     try {
90050       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90051     } catch (std::out_of_range& e) {
90052       {
90053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90054       };
90055     } catch (std::exception& e) {
90056       {
90057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90058       };
90059     } catch (Dali::DaliException e) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90062       };
90063     } catch (...) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90066       };
90067     }
90068   }
90069
90070   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90071   return jresult;
90072 }
90073
90074
90075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90076   void * jresult ;
90077   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90078
90079   {
90080     try {
90081       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90082     } catch (std::out_of_range& e) {
90083       {
90084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90085       };
90086     } catch (std::exception& e) {
90087       {
90088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90089       };
90090     } catch (Dali::DaliException e) {
90091       {
90092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90097       };
90098     }
90099   }
90100
90101   jresult = (void *)result;
90102   return jresult;
90103 }
90104
90105
90106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90107   void * jresult ;
90108   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90109   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90110
90111   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90112   if (!arg1) {
90113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90114     return 0;
90115   }
90116   {
90117     try {
90118       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90119     } catch (std::out_of_range& e) {
90120       {
90121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90122       };
90123     } catch (std::exception& e) {
90124       {
90125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90126       };
90127     } catch (Dali::DaliException e) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90130       };
90131     } catch (...) {
90132       {
90133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90134       };
90135     }
90136   }
90137
90138   jresult = (void *)result;
90139   return jresult;
90140 }
90141
90142
90143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90144   void * jresult ;
90145   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90146   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90147   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90148
90149   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90150   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90151   if (!arg2) {
90152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90153     return 0;
90154   }
90155   {
90156     try {
90157       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (Dali::DaliException e) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90169       };
90170     } catch (...) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90173       };
90174     }
90175   }
90176
90177   jresult = (void *)result;
90178   return jresult;
90179 }
90180
90181
90182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90183   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90184
90185   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90186   {
90187     try {
90188       delete arg1;
90189     } catch (std::out_of_range& e) {
90190       {
90191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90192       };
90193     } catch (std::exception& e) {
90194       {
90195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90196       };
90197     } catch (Dali::DaliException e) {
90198       {
90199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90204       };
90205     }
90206   }
90207
90208 }
90209
90210
90211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90212   void * jresult ;
90213   Dali::Toolkit::PageFactory *arg1 = 0 ;
90214   Dali::Vector2 *arg2 = 0 ;
90215   Dali::Toolkit::PageTurnPortraitView result;
90216
90217   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90218   if (!arg1) {
90219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90220     return 0;
90221   }
90222   arg2 = (Dali::Vector2 *)jarg2;
90223   if (!arg2) {
90224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90225     return 0;
90226   }
90227   {
90228     try {
90229       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90230     } catch (std::out_of_range& e) {
90231       {
90232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90233       };
90234     } catch (std::exception& e) {
90235       {
90236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90237       };
90238     } catch (Dali::DaliException e) {
90239       {
90240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90241       };
90242     } catch (...) {
90243       {
90244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90245       };
90246     }
90247   }
90248
90249   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90250   return jresult;
90251 }
90252
90253
90254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90255   void * jresult ;
90256   Dali::BaseHandle arg1 ;
90257   Dali::BaseHandle *argp1 ;
90258   Dali::Toolkit::PageTurnPortraitView result;
90259
90260   argp1 = (Dali::BaseHandle *)jarg1;
90261   if (!argp1) {
90262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90263     return 0;
90264   }
90265   arg1 = *argp1;
90266   {
90267     try {
90268       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (Dali::DaliException e) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90284       };
90285     }
90286   }
90287
90288   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90289   return jresult;
90290 }
90291
90292
90293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90294   int jresult ;
90295   int result;
90296
90297   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90298   jresult = (int)result;
90299   return jresult;
90300 }
90301
90302
90303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90304   int jresult ;
90305   int result;
90306
90307   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90308   jresult = (int)result;
90309   return jresult;
90310 }
90311
90312
90313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90314   int jresult ;
90315   int result;
90316
90317   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90318   jresult = (int)result;
90319   return jresult;
90320 }
90321
90322
90323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90324   void * jresult ;
90325   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90326
90327   {
90328     try {
90329       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90330     } catch (std::out_of_range& e) {
90331       {
90332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90333       };
90334     } catch (std::exception& e) {
90335       {
90336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90337       };
90338     } catch (Dali::DaliException e) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90345       };
90346     }
90347   }
90348
90349   jresult = (void *)result;
90350   return jresult;
90351 }
90352
90353
90354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90355   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90356
90357   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90358   {
90359     try {
90360       delete arg1;
90361     } catch (std::out_of_range& e) {
90362       {
90363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90364       };
90365     } catch (std::exception& e) {
90366       {
90367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90368       };
90369     } catch (Dali::DaliException e) {
90370       {
90371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90372       };
90373     } catch (...) {
90374       {
90375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90376       };
90377     }
90378   }
90379
90380 }
90381
90382
90383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90384   void * jresult ;
90385   Dali::Toolkit::ToggleButton *result = 0 ;
90386
90387   {
90388     try {
90389       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90390     } catch (std::out_of_range& e) {
90391       {
90392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90393       };
90394     } catch (std::exception& e) {
90395       {
90396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (Dali::DaliException e) {
90399       {
90400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90401       };
90402     } catch (...) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90405       };
90406     }
90407   }
90408
90409   jresult = (void *)result;
90410   return jresult;
90411 }
90412
90413
90414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90415   void * jresult ;
90416   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90417   Dali::Toolkit::ToggleButton *result = 0 ;
90418
90419   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90420   if (!arg1) {
90421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90422     return 0;
90423   }
90424   {
90425     try {
90426       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90427     } catch (std::out_of_range& e) {
90428       {
90429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90430       };
90431     } catch (std::exception& e) {
90432       {
90433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90434       };
90435     } catch (Dali::DaliException e) {
90436       {
90437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90438       };
90439     } catch (...) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90442       };
90443     }
90444   }
90445
90446   jresult = (void *)result;
90447   return jresult;
90448 }
90449
90450
90451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90452   void * jresult ;
90453   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90454   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90455   Dali::Toolkit::ToggleButton *result = 0 ;
90456
90457   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90458   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90459   if (!arg2) {
90460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90461     return 0;
90462   }
90463   {
90464     try {
90465       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90466     } catch (std::out_of_range& e) {
90467       {
90468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (std::exception& e) {
90471       {
90472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90473       };
90474     } catch (Dali::DaliException e) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90477       };
90478     } catch (...) {
90479       {
90480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90481       };
90482     }
90483   }
90484
90485   jresult = (void *)result;
90486   return jresult;
90487 }
90488
90489
90490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90491   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90492
90493   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90494   {
90495     try {
90496       delete arg1;
90497     } catch (std::out_of_range& e) {
90498       {
90499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90500       };
90501     } catch (std::exception& e) {
90502       {
90503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90504       };
90505     } catch (Dali::DaliException e) {
90506       {
90507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90508       };
90509     } catch (...) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90512       };
90513     }
90514   }
90515
90516 }
90517
90518
90519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90520   void * jresult ;
90521   Dali::Toolkit::ToggleButton result;
90522
90523   {
90524     try {
90525       result = Dali::Toolkit::ToggleButton::New();
90526     } catch (std::out_of_range& e) {
90527       {
90528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90529       };
90530     } catch (std::exception& e) {
90531       {
90532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90533       };
90534     } catch (Dali::DaliException e) {
90535       {
90536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90537       };
90538     } catch (...) {
90539       {
90540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90541       };
90542     }
90543   }
90544
90545   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90546   return jresult;
90547 }
90548
90549
90550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90551   void * jresult ;
90552   Dali::BaseHandle arg1 ;
90553   Dali::BaseHandle *argp1 ;
90554   Dali::Toolkit::ToggleButton result;
90555
90556   argp1 = (Dali::BaseHandle *)jarg1;
90557   if (!argp1) {
90558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90559     return 0;
90560   }
90561   arg1 = *argp1;
90562   {
90563     try {
90564       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90565     } catch (std::out_of_range& e) {
90566       {
90567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90568       };
90569     } catch (std::exception& e) {
90570       {
90571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90572       };
90573     } catch (Dali::DaliException e) {
90574       {
90575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90576       };
90577     } catch (...) {
90578       {
90579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90580       };
90581     }
90582   }
90583
90584   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90585   return jresult;
90586 }
90587
90588
90589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90590   void * jresult ;
90591   Dali::Toolkit::Visual::Base *result = 0 ;
90592
90593   {
90594     try {
90595       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90596     } catch (std::out_of_range& e) {
90597       {
90598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90599       };
90600     } catch (std::exception& e) {
90601       {
90602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90603       };
90604     } catch (Dali::DaliException e) {
90605       {
90606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90607       };
90608     } catch (...) {
90609       {
90610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90611       };
90612     }
90613   }
90614
90615   jresult = (void *)result;
90616   return jresult;
90617 }
90618
90619
90620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90621   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90622
90623   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90624   {
90625     try {
90626       delete arg1;
90627     } catch (std::out_of_range& e) {
90628       {
90629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90630       };
90631     } catch (std::exception& e) {
90632       {
90633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90634       };
90635     } catch (Dali::DaliException e) {
90636       {
90637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90638       };
90639     } catch (...) {
90640       {
90641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90642       };
90643     }
90644   }
90645
90646 }
90647
90648
90649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90650   void * jresult ;
90651   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90652   Dali::Toolkit::Visual::Base *result = 0 ;
90653
90654   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90655   if (!arg1) {
90656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90657     return 0;
90658   }
90659   {
90660     try {
90661       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90662     } catch (std::out_of_range& e) {
90663       {
90664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90665       };
90666     } catch (std::exception& e) {
90667       {
90668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90669       };
90670     } catch (Dali::DaliException e) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90673       };
90674     } catch (...) {
90675       {
90676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90677       };
90678     }
90679   }
90680
90681   jresult = (void *)result;
90682   return jresult;
90683 }
90684
90685
90686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90687   void * jresult ;
90688   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90689   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90690   Dali::Toolkit::Visual::Base *result = 0 ;
90691
90692   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90693   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90694   if (!arg2) {
90695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90696     return 0;
90697   }
90698   {
90699     try {
90700       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90701     } catch (std::out_of_range& e) {
90702       {
90703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90704       };
90705     } catch (std::exception& e) {
90706       {
90707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90708       };
90709     } catch (Dali::DaliException e) {
90710       {
90711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90712       };
90713     } catch (...) {
90714       {
90715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90716       };
90717     }
90718   }
90719
90720   jresult = (void *)result;
90721   return jresult;
90722 }
90723
90724
90725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90726   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90727   std::string *arg2 = 0 ;
90728
90729   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90730   if (!jarg2) {
90731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90732     return ;
90733   }
90734   std::string arg2_str(jarg2);
90735   arg2 = &arg2_str;
90736   {
90737     try {
90738       (arg1)->SetName((std::string const &)*arg2);
90739     } catch (std::out_of_range& e) {
90740       {
90741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90742       };
90743     } catch (std::exception& e) {
90744       {
90745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90746       };
90747     } catch (Dali::DaliException e) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90750       };
90751     } catch (...) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90754       };
90755     }
90756   }
90757
90758
90759   //argout typemap for const std::string&
90760
90761 }
90762
90763
90764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90765   char * jresult ;
90766   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90767   std::string *result = 0 ;
90768
90769   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90770   {
90771     try {
90772       result = (std::string *) &(arg1)->GetName();
90773     } catch (std::out_of_range& e) {
90774       {
90775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90776       };
90777     } catch (std::exception& e) {
90778       {
90779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90780       };
90781     } catch (Dali::DaliException e) {
90782       {
90783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90784       };
90785     } catch (...) {
90786       {
90787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90788       };
90789     }
90790   }
90791
90792   jresult = SWIG_csharp_string_callback(result->c_str());
90793   return jresult;
90794 }
90795
90796
90797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90798   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90799   Dali::Property::Map *arg2 = 0 ;
90800   Dali::Size arg3 ;
90801   Dali::Size *argp3 ;
90802
90803   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90804   arg2 = (Dali::Property::Map *)jarg2;
90805   if (!arg2) {
90806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90807     return ;
90808   }
90809   argp3 = (Dali::Size *)jarg3;
90810   if (!argp3) {
90811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90812     return ;
90813   }
90814   arg3 = *argp3;
90815   {
90816     try {
90817       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90818     } catch (std::out_of_range& e) {
90819       {
90820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90821       };
90822     } catch (std::exception& e) {
90823       {
90824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90825       };
90826     } catch (Dali::DaliException e) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90829       };
90830     } catch (...) {
90831       {
90832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90833       };
90834     }
90835   }
90836
90837 }
90838
90839
90840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90841   float jresult ;
90842   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90843   float arg2 ;
90844   float result;
90845
90846   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90847   arg2 = (float)jarg2;
90848   {
90849     try {
90850       result = (float)(arg1)->GetHeightForWidth(arg2);
90851     } catch (std::out_of_range& e) {
90852       {
90853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90854       };
90855     } catch (std::exception& e) {
90856       {
90857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90858       };
90859     } catch (Dali::DaliException e) {
90860       {
90861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90862       };
90863     } catch (...) {
90864       {
90865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90866       };
90867     }
90868   }
90869
90870   jresult = result;
90871   return jresult;
90872 }
90873
90874
90875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90876   float jresult ;
90877   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90878   float arg2 ;
90879   float result;
90880
90881   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90882   arg2 = (float)jarg2;
90883   {
90884     try {
90885       result = (float)(arg1)->GetWidthForHeight(arg2);
90886     } catch (std::out_of_range& e) {
90887       {
90888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (std::exception& e) {
90891       {
90892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90893       };
90894     } catch (Dali::DaliException e) {
90895       {
90896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90897       };
90898     } catch (...) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90901       };
90902     }
90903   }
90904
90905   jresult = result;
90906   return jresult;
90907 }
90908
90909
90910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90911   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90912   Dali::Vector2 *arg2 = 0 ;
90913
90914   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90915   arg2 = (Dali::Vector2 *)jarg2;
90916   if (!arg2) {
90917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90918     return ;
90919   }
90920   {
90921     try {
90922       (arg1)->GetNaturalSize(*arg2);
90923     } catch (std::out_of_range& e) {
90924       {
90925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90926       };
90927     } catch (std::exception& e) {
90928       {
90929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90930       };
90931     } catch (Dali::DaliException e) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90934       };
90935     } catch (...) {
90936       {
90937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90938       };
90939     }
90940   }
90941
90942 }
90943
90944
90945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90946   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90947   float arg2 ;
90948
90949   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90950   arg2 = (int)jarg2;
90951   {
90952     try {
90953       (arg1)->SetDepthIndex(arg2);
90954     } catch (std::out_of_range& e) {
90955       {
90956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90957       };
90958     } catch (std::exception& e) {
90959       {
90960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (Dali::DaliException e) {
90963       {
90964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90965       };
90966     } catch (...) {
90967       {
90968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90969       };
90970     }
90971   }
90972
90973 }
90974
90975
90976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90977   int jresult ;
90978   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90979   int result;
90980
90981   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90982   {
90983     try {
90984       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90985     } catch (std::out_of_range& e) {
90986       {
90987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90988       };
90989     } catch (std::exception& e) {
90990       {
90991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90992       };
90993     } catch (Dali::DaliException e) {
90994       {
90995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90996       };
90997     } catch (...) {
90998       {
90999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91000       };
91001     }
91002   }
91003
91004   jresult = result;
91005   return jresult;
91006 }
91007
91008
91009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91010   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91011   Dali::Property::Map *arg2 = 0 ;
91012
91013   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91014   arg2 = (Dali::Property::Map *)jarg2;
91015   if (!arg2) {
91016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91017     return ;
91018   }
91019   {
91020     try {
91021       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91022     } catch (std::out_of_range& e) {
91023       {
91024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91025       };
91026     } catch (std::exception& e) {
91027       {
91028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91029       };
91030     } catch (Dali::DaliException e) {
91031       {
91032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91033       };
91034     } catch (...) {
91035       {
91036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91037       };
91038     }
91039   }
91040
91041 }
91042
91043
91044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91045   void * jresult ;
91046   Dali::Toolkit::VisualFactory result;
91047
91048   {
91049     try {
91050       result = Dali::Toolkit::VisualFactory::Get();
91051     } catch (std::out_of_range& e) {
91052       {
91053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91054       };
91055     } catch (std::exception& e) {
91056       {
91057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91058       };
91059     } catch (Dali::DaliException e) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91062       };
91063     } catch (...) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91066       };
91067     }
91068   }
91069
91070   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91071   return jresult;
91072 }
91073
91074
91075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91076   void * jresult ;
91077   Dali::Toolkit::VisualFactory *result = 0 ;
91078
91079   {
91080     try {
91081       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91082     } catch (std::out_of_range& e) {
91083       {
91084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (std::exception& e) {
91087       {
91088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91089       };
91090     } catch (Dali::DaliException e) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91093       };
91094     } catch (...) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91097       };
91098     }
91099   }
91100
91101   jresult = (void *)result;
91102   return jresult;
91103 }
91104
91105
91106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91107   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91108
91109   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91110   {
91111     try {
91112       delete arg1;
91113     } catch (std::out_of_range& e) {
91114       {
91115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91116       };
91117     } catch (std::exception& e) {
91118       {
91119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91120       };
91121     } catch (Dali::DaliException e) {
91122       {
91123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91124       };
91125     } catch (...) {
91126       {
91127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91128       };
91129     }
91130   }
91131
91132 }
91133
91134
91135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91136   void * jresult ;
91137   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91138   Dali::Toolkit::VisualFactory *result = 0 ;
91139
91140   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91141   if (!arg1) {
91142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91143     return 0;
91144   }
91145   {
91146     try {
91147       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91148     } catch (std::out_of_range& e) {
91149       {
91150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (std::exception& e) {
91153       {
91154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91155       };
91156     } catch (Dali::DaliException e) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91159       };
91160     } catch (...) {
91161       {
91162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91163       };
91164     }
91165   }
91166
91167   jresult = (void *)result;
91168   return jresult;
91169 }
91170
91171
91172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91173   void * jresult ;
91174   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91175   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91176   Dali::Toolkit::VisualFactory *result = 0 ;
91177
91178   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91179   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91180   if (!arg2) {
91181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91182     return 0;
91183   }
91184   {
91185     try {
91186       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91187     } catch (std::out_of_range& e) {
91188       {
91189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91190       };
91191     } catch (std::exception& e) {
91192       {
91193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91194       };
91195     } catch (Dali::DaliException e) {
91196       {
91197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91198       };
91199     } catch (...) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91202       };
91203     }
91204   }
91205
91206   jresult = (void *)result;
91207   return jresult;
91208 }
91209
91210
91211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91212   void * jresult ;
91213   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91214   Dali::Property::Map *arg2 = 0 ;
91215   Dali::Toolkit::Visual::Base result;
91216
91217   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91218   arg2 = (Dali::Property::Map *)jarg2;
91219   if (!arg2) {
91220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91221     return 0;
91222   }
91223   {
91224     try {
91225       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91226     } catch (std::out_of_range& e) {
91227       {
91228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91229       };
91230     } catch (std::exception& e) {
91231       {
91232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91233       };
91234     } catch (Dali::DaliException e) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91237       };
91238     } catch (...) {
91239       {
91240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91241       };
91242     }
91243   }
91244
91245   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91246   return jresult;
91247 }
91248
91249
91250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91251   void * jresult ;
91252   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91253   Dali::Image *arg2 = 0 ;
91254   Dali::Toolkit::Visual::Base result;
91255
91256   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91257   arg2 = (Dali::Image *)jarg2;
91258   if (!arg2) {
91259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91260     return 0;
91261   }
91262   {
91263     try {
91264       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91265     } catch (std::out_of_range& e) {
91266       {
91267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91268       };
91269     } catch (std::exception& e) {
91270       {
91271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91272       };
91273     } catch (Dali::DaliException e) {
91274       {
91275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91276       };
91277     } catch (...) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91280       };
91281     }
91282   }
91283
91284   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91285   return jresult;
91286 }
91287
91288
91289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91290   void * jresult ;
91291   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91292   std::string *arg2 = 0 ;
91293   Dali::ImageDimensions arg3 ;
91294   Dali::ImageDimensions *argp3 ;
91295   Dali::Toolkit::Visual::Base result;
91296
91297   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91298   if (!jarg2) {
91299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91300     return 0;
91301   }
91302   std::string arg2_str(jarg2);
91303   arg2 = &arg2_str;
91304   argp3 = (Dali::ImageDimensions *)jarg3;
91305   if (!argp3) {
91306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91307     return 0;
91308   }
91309   arg3 = *argp3;
91310   {
91311     try {
91312       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91313     } catch (std::out_of_range& e) {
91314       {
91315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91316       };
91317     } catch (std::exception& e) {
91318       {
91319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (Dali::DaliException e) {
91322       {
91323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91324       };
91325     } catch (...) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91328       };
91329     }
91330   }
91331
91332   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91333
91334   //argout typemap for const std::string&
91335
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91341   void * jresult ;
91342   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91343
91344   {
91345     try {
91346       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91347     } catch (std::out_of_range& e) {
91348       {
91349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91350       };
91351     } catch (std::exception& e) {
91352       {
91353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91354       };
91355     } catch (Dali::DaliException e) {
91356       {
91357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91358       };
91359     } catch (...) {
91360       {
91361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91362       };
91363     }
91364   }
91365
91366   jresult = (void *)result;
91367   return jresult;
91368 }
91369
91370
91371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91372   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91373
91374   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91375   {
91376     try {
91377       delete arg1;
91378     } catch (std::out_of_range& e) {
91379       {
91380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91381       };
91382     } catch (std::exception& e) {
91383       {
91384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91385       };
91386     } catch (Dali::DaliException e) {
91387       {
91388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91389       };
91390     } catch (...) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91393       };
91394     }
91395   }
91396
91397 }
91398
91399
91400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91401   void * jresult ;
91402   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91403   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91404
91405   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91406   if (!arg1) {
91407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91408     return 0;
91409   }
91410   {
91411     try {
91412       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91413     } catch (std::out_of_range& e) {
91414       {
91415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91416       };
91417     } catch (std::exception& e) {
91418       {
91419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91420       };
91421     } catch (Dali::DaliException e) {
91422       {
91423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91424       };
91425     } catch (...) {
91426       {
91427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91428       };
91429     }
91430   }
91431
91432   jresult = (void *)result;
91433   return jresult;
91434 }
91435
91436
91437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91438   void * jresult ;
91439   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91440   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91441   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91442
91443   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91444   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91445   if (!arg2) {
91446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91447     return 0;
91448   }
91449   {
91450     try {
91451       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (Dali::DaliException e) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91463       };
91464     } catch (...) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91467       };
91468     }
91469   }
91470
91471   jresult = (void *)result;
91472   return jresult;
91473 }
91474
91475
91476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91477   void * jresult ;
91478   Dali::Toolkit::AsyncImageLoader result;
91479
91480   {
91481     try {
91482       result = Dali::Toolkit::AsyncImageLoader::New();
91483     } catch (std::out_of_range& e) {
91484       {
91485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91486       };
91487     } catch (std::exception& e) {
91488       {
91489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91490       };
91491     } catch (Dali::DaliException e) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91498       };
91499     }
91500   }
91501
91502   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91503   return jresult;
91504 }
91505
91506
91507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91508   void * jresult ;
91509   Dali::BaseHandle arg1 ;
91510   Dali::BaseHandle *argp1 ;
91511   Dali::Toolkit::AsyncImageLoader result;
91512
91513   argp1 = (Dali::BaseHandle *)jarg1;
91514   if (!argp1) {
91515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91516     return 0;
91517   }
91518   arg1 = *argp1;
91519   {
91520     try {
91521       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91537       };
91538     }
91539   }
91540
91541   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91542   return jresult;
91543 }
91544
91545
91546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91547   unsigned int jresult ;
91548   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91549   std::string *arg2 = 0 ;
91550   uint32_t result;
91551
91552   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91553   if (!jarg2) {
91554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91555     return 0;
91556   }
91557   std::string arg2_str(jarg2);
91558   arg2 = &arg2_str;
91559   {
91560     try {
91561       result = (arg1)->Load((std::string const &)*arg2);
91562     } catch (std::out_of_range& e) {
91563       {
91564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91565       };
91566     } catch (std::exception& e) {
91567       {
91568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91569       };
91570     } catch (Dali::DaliException e) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91573       };
91574     } catch (...) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91577       };
91578     }
91579   }
91580
91581   jresult = result;
91582
91583   //argout typemap for const std::string&
91584
91585   return jresult;
91586 }
91587
91588
91589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91590   unsigned int jresult ;
91591   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91592   std::string *arg2 = 0 ;
91593   Dali::ImageDimensions arg3 ;
91594   Dali::ImageDimensions *argp3 ;
91595   uint32_t result;
91596
91597   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91598   if (!jarg2) {
91599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91600     return 0;
91601   }
91602   std::string arg2_str(jarg2);
91603   arg2 = &arg2_str;
91604   argp3 = (Dali::ImageDimensions *)jarg3;
91605   if (!argp3) {
91606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91607     return 0;
91608   }
91609   arg3 = *argp3;
91610   {
91611     try {
91612       result = (arg1)->Load((std::string const &)*arg2,arg3);
91613     } catch (std::out_of_range& e) {
91614       {
91615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91616       };
91617     } catch (std::exception& e) {
91618       {
91619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91620       };
91621     } catch (Dali::DaliException e) {
91622       {
91623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91624       };
91625     } catch (...) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91628       };
91629     }
91630   }
91631
91632   jresult = result;
91633
91634   //argout typemap for const std::string&
91635
91636   return jresult;
91637 }
91638
91639
91640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91641   unsigned int jresult ;
91642   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91643   std::string *arg2 = 0 ;
91644   Dali::ImageDimensions arg3 ;
91645   Dali::FittingMode::Type arg4 ;
91646   Dali::SamplingMode::Type arg5 ;
91647   bool arg6 ;
91648   Dali::ImageDimensions *argp3 ;
91649   uint32_t result;
91650
91651   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91652   if (!jarg2) {
91653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91654     return 0;
91655   }
91656   std::string arg2_str(jarg2);
91657   arg2 = &arg2_str;
91658   argp3 = (Dali::ImageDimensions *)jarg3;
91659   if (!argp3) {
91660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91661     return 0;
91662   }
91663   arg3 = *argp3;
91664   arg4 = (Dali::FittingMode::Type)jarg4;
91665   arg5 = (Dali::SamplingMode::Type)jarg5;
91666   arg6 = jarg6 ? true : false;
91667   {
91668     try {
91669       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91670     } catch (std::out_of_range& e) {
91671       {
91672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91673       };
91674     } catch (std::exception& e) {
91675       {
91676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91677       };
91678     } catch (Dali::DaliException e) {
91679       {
91680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91681       };
91682     } catch (...) {
91683       {
91684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91685       };
91686     }
91687   }
91688
91689   jresult = result;
91690
91691   //argout typemap for const std::string&
91692
91693   return jresult;
91694 }
91695
91696
91697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91698   unsigned int jresult ;
91699   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91700   uint32_t arg2 ;
91701   bool result;
91702
91703   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91704   arg2 = (uint32_t)jarg2;
91705   {
91706     try {
91707       result = (bool)(arg1)->Cancel(arg2);
91708     } catch (std::out_of_range& e) {
91709       {
91710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91711       };
91712     } catch (std::exception& e) {
91713       {
91714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91715       };
91716     } catch (Dali::DaliException e) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91719       };
91720     } catch (...) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91723       };
91724     }
91725   }
91726
91727   jresult = result;
91728   return jresult;
91729 }
91730
91731
91732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91733   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91734
91735   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91736   {
91737     try {
91738       (arg1)->CancelAll();
91739     } catch (std::out_of_range& e) {
91740       {
91741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91742       };
91743     } catch (std::exception& e) {
91744       {
91745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91746       };
91747     } catch (Dali::DaliException e) {
91748       {
91749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91754       };
91755     }
91756   }
91757
91758 }
91759
91760
91761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91762   void * jresult ;
91763   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91764   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91765
91766   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91767   {
91768     try {
91769       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91770     } catch (std::out_of_range& e) {
91771       {
91772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91773       };
91774     } catch (std::exception& e) {
91775       {
91776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91777       };
91778     } catch (Dali::DaliException e) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91781       };
91782     } catch (...) {
91783       {
91784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91785       };
91786     }
91787   }
91788
91789   jresult = (void *)result;
91790   return jresult;
91791 }
91792
91793
91794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91795   void * jresult ;
91796   std::string *arg1 = 0 ;
91797   Dali::PixelData result;
91798
91799   if (!jarg1) {
91800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91801     return 0;
91802   }
91803   std::string arg1_str(jarg1);
91804   arg1 = &arg1_str;
91805   {
91806     try {
91807       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91808     } catch (std::out_of_range& e) {
91809       {
91810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91811       };
91812     } catch (std::exception& e) {
91813       {
91814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91815       };
91816     } catch (Dali::DaliException e) {
91817       {
91818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91819       };
91820     } catch (...) {
91821       {
91822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91823       };
91824     }
91825   }
91826
91827   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91828
91829   //argout typemap for const std::string&
91830
91831   return jresult;
91832 }
91833
91834
91835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91836   void * jresult ;
91837   std::string *arg1 = 0 ;
91838   Dali::ImageDimensions arg2 ;
91839   Dali::ImageDimensions *argp2 ;
91840   Dali::PixelData result;
91841
91842   if (!jarg1) {
91843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91844     return 0;
91845   }
91846   std::string arg1_str(jarg1);
91847   arg1 = &arg1_str;
91848   argp2 = (Dali::ImageDimensions *)jarg2;
91849   if (!argp2) {
91850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91851     return 0;
91852   }
91853   arg2 = *argp2;
91854   {
91855     try {
91856       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91864       };
91865     } catch (Dali::DaliException e) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91868       };
91869     } catch (...) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91872       };
91873     }
91874   }
91875
91876   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91877
91878   //argout typemap for const std::string&
91879
91880   return jresult;
91881 }
91882
91883
91884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91885   void * jresult ;
91886   std::string *arg1 = 0 ;
91887   Dali::ImageDimensions arg2 ;
91888   Dali::FittingMode::Type arg3 ;
91889   Dali::SamplingMode::Type arg4 ;
91890   bool arg5 ;
91891   Dali::ImageDimensions *argp2 ;
91892   Dali::PixelData result;
91893
91894   if (!jarg1) {
91895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91896     return 0;
91897   }
91898   std::string arg1_str(jarg1);
91899   arg1 = &arg1_str;
91900   argp2 = (Dali::ImageDimensions *)jarg2;
91901   if (!argp2) {
91902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91903     return 0;
91904   }
91905   arg2 = *argp2;
91906   arg3 = (Dali::FittingMode::Type)jarg3;
91907   arg4 = (Dali::SamplingMode::Type)jarg4;
91908   arg5 = jarg5 ? true : false;
91909   {
91910     try {
91911       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (Dali::DaliException e) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91923       };
91924     } catch (...) {
91925       {
91926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91927       };
91928     }
91929   }
91930
91931   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91932
91933   //argout typemap for const std::string&
91934
91935   return jresult;
91936 }
91937
91938
91939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91940   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91941
91942   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91943   {
91944     try {
91945       delete arg1;
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91953       };
91954     } catch (Dali::DaliException e) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91957       };
91958     } catch (...) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91961       };
91962     }
91963   }
91964
91965 }
91966
91967
91968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91969   void * jresult ;
91970   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91971   Dali::Actor arg2 ;
91972   Dali::Actor arg3 ;
91973   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91974   Dali::Actor *argp2 ;
91975   Dali::Actor *argp3 ;
91976   Dali::Actor result;
91977
91978   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91979   argp2 = (Dali::Actor *)jarg2;
91980   if (!argp2) {
91981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91982     return 0;
91983   }
91984   arg2 = *argp2;
91985   argp3 = (Dali::Actor *)jarg3;
91986   if (!argp3) {
91987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91988     return 0;
91989   }
91990   arg3 = *argp3;
91991   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91992   {
91993     try {
91994       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91995     } catch (std::out_of_range& e) {
91996       {
91997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (std::exception& e) {
92000       {
92001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92002       };
92003     } catch (Dali::DaliException e) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92006       };
92007     } catch (...) {
92008       {
92009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92010       };
92011     }
92012   }
92013
92014   jresult = new Dali::Actor((const Dali::Actor &)result);
92015   return jresult;
92016 }
92017
92018
92019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92020   void * jresult ;
92021   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92022
92023   {
92024     try {
92025       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (Dali::DaliException e) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92037       };
92038     } catch (...) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92041       };
92042     }
92043   }
92044
92045   jresult = (void *)result;
92046   return jresult;
92047 }
92048
92049
92050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92051   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92052   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92053   if (director) {
92054     director->swig_connect_director(callback0);
92055   }
92056 }
92057
92058
92059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92060   KeyboardFocusManager arg1 ;
92061   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92062   KeyboardFocusManager *argp1 ;
92063
92064   argp1 = (KeyboardFocusManager *)jarg1;
92065   if (!argp1) {
92066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92067     return ;
92068   }
92069   arg1 = *argp1;
92070   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92071   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92072   {
92073     try {
92074       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92075     } catch (std::out_of_range& e) {
92076       {
92077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92078       };
92079     } catch (std::exception& e) {
92080       {
92081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92082       };
92083     } catch (Dali::DaliException e) {
92084       {
92085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92086       };
92087     } catch (...) {
92088       {
92089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92090       };
92091     }
92092   }
92093
92094 }
92095
92096
92097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92098   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92099
92100   arg1 = (std::vector< unsigned int > *)jarg1;
92101   {
92102     try {
92103       (arg1)->clear();
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (Dali::DaliException e) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92115       };
92116     } catch (...) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92119       };
92120     }
92121   }
92122
92123 }
92124
92125
92126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92127   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92128   unsigned int *arg2 = 0 ;
92129   unsigned int temp2 ;
92130
92131   arg1 = (std::vector< unsigned int > *)jarg1;
92132   temp2 = (unsigned int)jarg2;
92133   arg2 = &temp2;
92134   {
92135     try {
92136       (arg1)->push_back((unsigned int const &)*arg2);
92137     } catch (std::out_of_range& e) {
92138       {
92139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92140       };
92141     } catch (std::exception& e) {
92142       {
92143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92144       };
92145     } catch (Dali::DaliException e) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92148       };
92149     } catch (...) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92152       };
92153     }
92154   }
92155
92156 }
92157
92158
92159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92160   unsigned long jresult ;
92161   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92162   std::vector< unsigned int >::size_type result;
92163
92164   arg1 = (std::vector< unsigned int > *)jarg1;
92165   {
92166     try {
92167       result = ((std::vector< unsigned int > const *)arg1)->size();
92168     } catch (std::out_of_range& e) {
92169       {
92170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92171       };
92172     } catch (std::exception& e) {
92173       {
92174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92175       };
92176     } catch (Dali::DaliException e) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92179       };
92180     } catch (...) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92183       };
92184     }
92185   }
92186
92187   jresult = (unsigned long)result;
92188   return jresult;
92189 }
92190
92191
92192 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92193   unsigned long jresult ;
92194   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92195   std::vector< unsigned int >::size_type result;
92196
92197   arg1 = (std::vector< unsigned int > *)jarg1;
92198   {
92199     try {
92200       result = ((std::vector< unsigned int > const *)arg1)->capacity();
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 = (unsigned long)result;
92221   return jresult;
92222 }
92223
92224
92225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92226   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92227   std::vector< unsigned int >::size_type arg2 ;
92228
92229   arg1 = (std::vector< unsigned int > *)jarg1;
92230   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92231   {
92232     try {
92233       (arg1)->reserve(arg2);
92234     } catch (std::out_of_range& e) {
92235       {
92236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92237       };
92238     } catch (std::exception& e) {
92239       {
92240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92241       };
92242     } catch (Dali::DaliException e) {
92243       {
92244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92245       };
92246     } catch (...) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92249       };
92250     }
92251   }
92252
92253 }
92254
92255
92256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92257   void * jresult ;
92258   std::vector< unsigned int > *result = 0 ;
92259
92260   {
92261     try {
92262       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92263     } catch (std::out_of_range& e) {
92264       {
92265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92266       };
92267     } catch (std::exception& e) {
92268       {
92269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92270       };
92271     } catch (Dali::DaliException e) {
92272       {
92273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92274       };
92275     } catch (...) {
92276       {
92277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92278       };
92279     }
92280   }
92281
92282   jresult = (void *)result;
92283   return jresult;
92284 }
92285
92286
92287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92288   void * jresult ;
92289   std::vector< unsigned int > *arg1 = 0 ;
92290   std::vector< unsigned int > *result = 0 ;
92291
92292   arg1 = (std::vector< unsigned int > *)jarg1;
92293   if (!arg1) {
92294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92295     return 0;
92296   }
92297   {
92298     try {
92299       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92300     } catch (std::out_of_range& e) {
92301       {
92302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92303       };
92304     } catch (std::exception& e) {
92305       {
92306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92307       };
92308     } catch (Dali::DaliException e) {
92309       {
92310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92311       };
92312     } catch (...) {
92313       {
92314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92315       };
92316     }
92317   }
92318
92319   jresult = (void *)result;
92320   return jresult;
92321 }
92322
92323
92324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92325   void * jresult ;
92326   int arg1 ;
92327   std::vector< unsigned int > *result = 0 ;
92328
92329   arg1 = (int)jarg1;
92330   {
92331     try {
92332       try {
92333         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92334       }
92335       catch(std::out_of_range &_e) {
92336         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92337         return 0;
92338       }
92339
92340     } catch (std::out_of_range& e) {
92341       {
92342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (std::exception& e) {
92345       {
92346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92347       };
92348     } catch (Dali::DaliException e) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92351       };
92352     } catch (...) {
92353       {
92354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92355       };
92356     }
92357   }
92358
92359   jresult = (void *)result;
92360   return jresult;
92361 }
92362
92363
92364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92365   unsigned int jresult ;
92366   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92367   int arg2 ;
92368   unsigned int result;
92369
92370   arg1 = (std::vector< unsigned int > *)jarg1;
92371   arg2 = (int)jarg2;
92372   {
92373     try {
92374       try {
92375         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92376       }
92377       catch(std::out_of_range &_e) {
92378         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92379         return 0;
92380       }
92381
92382     } catch (std::out_of_range& e) {
92383       {
92384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (std::exception& e) {
92387       {
92388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92389       };
92390     } catch (Dali::DaliException e) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92393       };
92394     } catch (...) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92397       };
92398     }
92399   }
92400
92401   jresult = result;
92402   return jresult;
92403 }
92404
92405
92406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92407   unsigned int jresult ;
92408   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92409   int arg2 ;
92410   unsigned int *result = 0 ;
92411
92412   arg1 = (std::vector< unsigned int > *)jarg1;
92413   arg2 = (int)jarg2;
92414   {
92415     try {
92416       try {
92417         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92418       }
92419       catch(std::out_of_range &_e) {
92420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92421         return 0;
92422       }
92423
92424     } catch (std::out_of_range& e) {
92425       {
92426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92427       };
92428     } catch (std::exception& e) {
92429       {
92430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92431       };
92432     } catch (Dali::DaliException e) {
92433       {
92434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92435       };
92436     } catch (...) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92439       };
92440     }
92441   }
92442
92443   jresult = *result;
92444   return jresult;
92445 }
92446
92447
92448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92449   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92450   int arg2 ;
92451   unsigned int *arg3 = 0 ;
92452   unsigned int temp3 ;
92453
92454   arg1 = (std::vector< unsigned int > *)jarg1;
92455   arg2 = (int)jarg2;
92456   temp3 = (unsigned int)jarg3;
92457   arg3 = &temp3;
92458   {
92459     try {
92460       try {
92461         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92462       }
92463       catch(std::out_of_range &_e) {
92464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92465         return ;
92466       }
92467
92468     } catch (std::out_of_range& e) {
92469       {
92470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92471       };
92472     } catch (std::exception& e) {
92473       {
92474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92475       };
92476     } catch (Dali::DaliException e) {
92477       {
92478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92479       };
92480     } catch (...) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92483       };
92484     }
92485   }
92486
92487 }
92488
92489
92490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92491   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92492   std::vector< unsigned int > *arg2 = 0 ;
92493
92494   arg1 = (std::vector< unsigned int > *)jarg1;
92495   arg2 = (std::vector< unsigned int > *)jarg2;
92496   if (!arg2) {
92497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92498     return ;
92499   }
92500   {
92501     try {
92502       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92503     } catch (std::out_of_range& e) {
92504       {
92505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92506       };
92507     } catch (std::exception& e) {
92508       {
92509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (Dali::DaliException e) {
92512       {
92513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92514       };
92515     } catch (...) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92518       };
92519     }
92520   }
92521
92522 }
92523
92524
92525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92526   void * jresult ;
92527   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92528   int arg2 ;
92529   int arg3 ;
92530   std::vector< unsigned int > *result = 0 ;
92531
92532   arg1 = (std::vector< unsigned int > *)jarg1;
92533   arg2 = (int)jarg2;
92534   arg3 = (int)jarg3;
92535   {
92536     try {
92537       try {
92538         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92539       }
92540       catch(std::out_of_range &_e) {
92541         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92542         return 0;
92543       }
92544       catch(std::invalid_argument &_e) {
92545         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92546         return 0;
92547       }
92548
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92564       };
92565     }
92566   }
92567
92568   jresult = (void *)result;
92569   return jresult;
92570 }
92571
92572
92573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92574   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92575   int arg2 ;
92576   unsigned int *arg3 = 0 ;
92577   unsigned int temp3 ;
92578
92579   arg1 = (std::vector< unsigned int > *)jarg1;
92580   arg2 = (int)jarg2;
92581   temp3 = (unsigned int)jarg3;
92582   arg3 = &temp3;
92583   {
92584     try {
92585       try {
92586         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92587       }
92588       catch(std::out_of_range &_e) {
92589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92590         return ;
92591       }
92592
92593     } catch (std::out_of_range& e) {
92594       {
92595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92596       };
92597     } catch (std::exception& e) {
92598       {
92599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92600       };
92601     } catch (Dali::DaliException e) {
92602       {
92603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92604       };
92605     } catch (...) {
92606       {
92607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92608       };
92609     }
92610   }
92611
92612 }
92613
92614
92615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92616   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92617   int arg2 ;
92618   std::vector< unsigned int > *arg3 = 0 ;
92619
92620   arg1 = (std::vector< unsigned int > *)jarg1;
92621   arg2 = (int)jarg2;
92622   arg3 = (std::vector< unsigned int > *)jarg3;
92623   if (!arg3) {
92624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92625     return ;
92626   }
92627   {
92628     try {
92629       try {
92630         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92631       }
92632       catch(std::out_of_range &_e) {
92633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92634         return ;
92635       }
92636
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92644       };
92645     } catch (Dali::DaliException e) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92648       };
92649     } catch (...) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92652       };
92653     }
92654   }
92655
92656 }
92657
92658
92659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92660   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92661   int arg2 ;
92662
92663   arg1 = (std::vector< unsigned int > *)jarg1;
92664   arg2 = (int)jarg2;
92665   {
92666     try {
92667       try {
92668         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92669       }
92670       catch(std::out_of_range &_e) {
92671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92672         return ;
92673       }
92674
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92690       };
92691     }
92692   }
92693
92694 }
92695
92696
92697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92698   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92699   int arg2 ;
92700   int arg3 ;
92701
92702   arg1 = (std::vector< unsigned int > *)jarg1;
92703   arg2 = (int)jarg2;
92704   arg3 = (int)jarg3;
92705   {
92706     try {
92707       try {
92708         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92709       }
92710       catch(std::out_of_range &_e) {
92711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92712         return ;
92713       }
92714       catch(std::invalid_argument &_e) {
92715         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92716         return ;
92717       }
92718
92719     } catch (std::out_of_range& e) {
92720       {
92721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92722       };
92723     } catch (std::exception& e) {
92724       {
92725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92726       };
92727     } catch (Dali::DaliException e) {
92728       {
92729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92730       };
92731     } catch (...) {
92732       {
92733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92734       };
92735     }
92736   }
92737
92738 }
92739
92740
92741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92742   void * jresult ;
92743   unsigned int *arg1 = 0 ;
92744   int arg2 ;
92745   unsigned int temp1 ;
92746   std::vector< unsigned int > *result = 0 ;
92747
92748   temp1 = (unsigned int)jarg1;
92749   arg1 = &temp1;
92750   arg2 = (int)jarg2;
92751   {
92752     try {
92753       try {
92754         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92755       }
92756       catch(std::out_of_range &_e) {
92757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92758         return 0;
92759       }
92760
92761     } catch (std::out_of_range& e) {
92762       {
92763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92764       };
92765     } catch (std::exception& e) {
92766       {
92767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92768       };
92769     } catch (Dali::DaliException e) {
92770       {
92771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92772       };
92773     } catch (...) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92776       };
92777     }
92778   }
92779
92780   jresult = (void *)result;
92781   return jresult;
92782 }
92783
92784
92785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92786   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92787
92788   arg1 = (std::vector< unsigned int > *)jarg1;
92789   {
92790     try {
92791       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92792     } catch (std::out_of_range& e) {
92793       {
92794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92795       };
92796     } catch (std::exception& e) {
92797       {
92798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92799       };
92800     } catch (Dali::DaliException e) {
92801       {
92802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92803       };
92804     } catch (...) {
92805       {
92806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92807       };
92808     }
92809   }
92810
92811 }
92812
92813
92814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92815   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92816   int arg2 ;
92817   int arg3 ;
92818
92819   arg1 = (std::vector< unsigned int > *)jarg1;
92820   arg2 = (int)jarg2;
92821   arg3 = (int)jarg3;
92822   {
92823     try {
92824       try {
92825         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92826       }
92827       catch(std::out_of_range &_e) {
92828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92829         return ;
92830       }
92831       catch(std::invalid_argument &_e) {
92832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92833         return ;
92834       }
92835
92836     } catch (std::out_of_range& e) {
92837       {
92838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92839       };
92840     } catch (std::exception& e) {
92841       {
92842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92843       };
92844     } catch (Dali::DaliException e) {
92845       {
92846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92847       };
92848     } catch (...) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92851       };
92852     }
92853   }
92854
92855 }
92856
92857
92858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92859   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92860   int arg2 ;
92861   std::vector< unsigned int > *arg3 = 0 ;
92862
92863   arg1 = (std::vector< unsigned int > *)jarg1;
92864   arg2 = (int)jarg2;
92865   arg3 = (std::vector< unsigned int > *)jarg3;
92866   if (!arg3) {
92867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92868     return ;
92869   }
92870   {
92871     try {
92872       try {
92873         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92874       }
92875       catch(std::out_of_range &_e) {
92876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92877         return ;
92878       }
92879
92880     } catch (std::out_of_range& e) {
92881       {
92882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92883       };
92884     } catch (std::exception& e) {
92885       {
92886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92887       };
92888     } catch (Dali::DaliException e) {
92889       {
92890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92891       };
92892     } catch (...) {
92893       {
92894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92895       };
92896     }
92897   }
92898
92899 }
92900
92901
92902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92903   unsigned int jresult ;
92904   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92905   unsigned int *arg2 = 0 ;
92906   unsigned int temp2 ;
92907   bool result;
92908
92909   arg1 = (std::vector< unsigned int > *)jarg1;
92910   temp2 = (unsigned int)jarg2;
92911   arg2 = &temp2;
92912   {
92913     try {
92914       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92915     } catch (std::out_of_range& e) {
92916       {
92917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92918       };
92919     } catch (std::exception& e) {
92920       {
92921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92922       };
92923     } catch (Dali::DaliException e) {
92924       {
92925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92926       };
92927     } catch (...) {
92928       {
92929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92930       };
92931     }
92932   }
92933
92934   jresult = result;
92935   return jresult;
92936 }
92937
92938
92939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92940   int jresult ;
92941   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92942   unsigned int *arg2 = 0 ;
92943   unsigned int temp2 ;
92944   int result;
92945
92946   arg1 = (std::vector< unsigned int > *)jarg1;
92947   temp2 = (unsigned int)jarg2;
92948   arg2 = &temp2;
92949   {
92950     try {
92951       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92952     } catch (std::out_of_range& e) {
92953       {
92954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92955       };
92956     } catch (std::exception& e) {
92957       {
92958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92959       };
92960     } catch (Dali::DaliException e) {
92961       {
92962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92963       };
92964     } catch (...) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92967       };
92968     }
92969   }
92970
92971   jresult = result;
92972   return jresult;
92973 }
92974
92975
92976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92977   int jresult ;
92978   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92979   unsigned int *arg2 = 0 ;
92980   unsigned int temp2 ;
92981   int result;
92982
92983   arg1 = (std::vector< unsigned int > *)jarg1;
92984   temp2 = (unsigned int)jarg2;
92985   arg2 = &temp2;
92986   {
92987     try {
92988       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92989     } catch (std::out_of_range& e) {
92990       {
92991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92992       };
92993     } catch (std::exception& e) {
92994       {
92995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92996       };
92997     } catch (Dali::DaliException e) {
92998       {
92999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93000       };
93001     } catch (...) {
93002       {
93003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93004       };
93005     }
93006   }
93007
93008   jresult = result;
93009   return jresult;
93010 }
93011
93012
93013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93014   unsigned int jresult ;
93015   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93016   unsigned int *arg2 = 0 ;
93017   unsigned int temp2 ;
93018   bool result;
93019
93020   arg1 = (std::vector< unsigned int > *)jarg1;
93021   temp2 = (unsigned int)jarg2;
93022   arg2 = &temp2;
93023   {
93024     try {
93025       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93026     } catch (std::out_of_range& e) {
93027       {
93028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93029       };
93030     } catch (std::exception& e) {
93031       {
93032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93033       };
93034     } catch (Dali::DaliException e) {
93035       {
93036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93037       };
93038     } catch (...) {
93039       {
93040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93041       };
93042     }
93043   }
93044
93045   jresult = result;
93046   return jresult;
93047 }
93048
93049
93050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93051   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93052
93053   arg1 = (std::vector< unsigned int > *)jarg1;
93054   {
93055     try {
93056       delete arg1;
93057     } catch (std::out_of_range& e) {
93058       {
93059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93060       };
93061     } catch (std::exception& e) {
93062       {
93063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93064       };
93065     } catch (Dali::DaliException e) {
93066       {
93067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93068       };
93069     } catch (...) {
93070       {
93071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93072       };
93073     }
93074   }
93075
93076 }
93077
93078
93079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93080   void * jresult ;
93081   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93082
93083   {
93084     try {
93085       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93086     } catch (std::out_of_range& e) {
93087       {
93088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93089       };
93090     } catch (std::exception& e) {
93091       {
93092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93093       };
93094     } catch (Dali::DaliException e) {
93095       {
93096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93097       };
93098     } catch (...) {
93099       {
93100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93101       };
93102     }
93103   }
93104
93105   jresult = (void *)result;
93106   return jresult;
93107 }
93108
93109
93110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93111   void * jresult ;
93112   unsigned int arg1 ;
93113   Dali::Actor arg2 ;
93114   Dali::Actor *argp2 ;
93115   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93116
93117   arg1 = (unsigned int)jarg1;
93118   argp2 = (Dali::Actor *)jarg2;
93119   if (!argp2) {
93120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93121     return 0;
93122   }
93123   arg2 = *argp2;
93124   {
93125     try {
93126       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93127     } catch (std::out_of_range& e) {
93128       {
93129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93130       };
93131     } catch (std::exception& e) {
93132       {
93133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93134       };
93135     } catch (Dali::DaliException e) {
93136       {
93137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93138       };
93139     } catch (...) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93142       };
93143     }
93144   }
93145
93146   jresult = (void *)result;
93147   return jresult;
93148 }
93149
93150
93151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93152   void * jresult ;
93153   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93154   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93155
93156   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93157   if (!arg1) {
93158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93159     return 0;
93160   }
93161   {
93162     try {
93163       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93164     } catch (std::out_of_range& e) {
93165       {
93166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93167       };
93168     } catch (std::exception& e) {
93169       {
93170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93171       };
93172     } catch (Dali::DaliException e) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93175       };
93176     } catch (...) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93179       };
93180     }
93181   }
93182
93183   jresult = (void *)result;
93184   return jresult;
93185 }
93186
93187
93188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93189   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93190   unsigned int arg2 ;
93191
93192   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93193   arg2 = (unsigned int)jarg2;
93194   if (arg1) (arg1)->first = arg2;
93195 }
93196
93197
93198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93199   unsigned int jresult ;
93200   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93201   unsigned int result;
93202
93203   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93204   result = (unsigned int) ((arg1)->first);
93205   jresult = result;
93206   return jresult;
93207 }
93208
93209
93210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93211   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93212   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93213
93214   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93215   arg2 = (Dali::Actor *)jarg2;
93216   if (arg1) (arg1)->second = *arg2;
93217 }
93218
93219
93220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93221   void * jresult ;
93222   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93223   Dali::Actor *result = 0 ;
93224
93225   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93226   result = (Dali::Actor *)& ((arg1)->second);
93227   jresult = (void *)result;
93228   return jresult;
93229 }
93230
93231
93232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93233   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93234
93235   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93236   {
93237     try {
93238       delete arg1;
93239     } catch (std::out_of_range& e) {
93240       {
93241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93242       };
93243     } catch (std::exception& e) {
93244       {
93245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93246       };
93247     } catch (Dali::DaliException e) {
93248       {
93249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93250       };
93251     } catch (...) {
93252       {
93253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93254       };
93255     }
93256   }
93257
93258 }
93259
93260
93261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93262   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93263
93264   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93265   {
93266     try {
93267       (arg1)->clear();
93268     } catch (std::out_of_range& e) {
93269       {
93270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93271       };
93272     } catch (std::exception& e) {
93273       {
93274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93275       };
93276     } catch (Dali::DaliException e) {
93277       {
93278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93279       };
93280     } catch (...) {
93281       {
93282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93283       };
93284     }
93285   }
93286
93287 }
93288
93289
93290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93291   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93292   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93293
93294   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93295   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93296   if (!arg2) {
93297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93298     return ;
93299   }
93300   {
93301     try {
93302       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93303     } catch (std::out_of_range& e) {
93304       {
93305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93306       };
93307     } catch (std::exception& e) {
93308       {
93309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93310       };
93311     } catch (Dali::DaliException e) {
93312       {
93313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93314       };
93315     } catch (...) {
93316       {
93317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93318       };
93319     }
93320   }
93321
93322 }
93323
93324
93325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93326   unsigned long jresult ;
93327   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93328   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93329
93330   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93331   {
93332     try {
93333       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93334     } catch (std::out_of_range& e) {
93335       {
93336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93337       };
93338     } catch (std::exception& e) {
93339       {
93340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93341       };
93342     } catch (Dali::DaliException e) {
93343       {
93344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93345       };
93346     } catch (...) {
93347       {
93348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93349       };
93350     }
93351   }
93352
93353   jresult = (unsigned long)result;
93354   return jresult;
93355 }
93356
93357
93358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93359   unsigned long jresult ;
93360   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93361   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93362
93363   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93364   {
93365     try {
93366       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93367     } catch (std::out_of_range& e) {
93368       {
93369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93370       };
93371     } catch (std::exception& e) {
93372       {
93373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93374       };
93375     } catch (Dali::DaliException e) {
93376       {
93377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93378       };
93379     } catch (...) {
93380       {
93381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93382       };
93383     }
93384   }
93385
93386   jresult = (unsigned long)result;
93387   return jresult;
93388 }
93389
93390
93391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93392   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93393   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93394
93395   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93396   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93397   {
93398     try {
93399       (arg1)->reserve(arg2);
93400     } catch (std::out_of_range& e) {
93401       {
93402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93403       };
93404     } catch (std::exception& e) {
93405       {
93406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93407       };
93408     } catch (Dali::DaliException e) {
93409       {
93410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93411       };
93412     } catch (...) {
93413       {
93414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93415       };
93416     }
93417   }
93418
93419 }
93420
93421
93422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93423   void * jresult ;
93424   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93425
93426   {
93427     try {
93428       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93429     } catch (std::out_of_range& e) {
93430       {
93431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93432       };
93433     } catch (std::exception& e) {
93434       {
93435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93436       };
93437     } catch (Dali::DaliException e) {
93438       {
93439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93440       };
93441     } catch (...) {
93442       {
93443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93444       };
93445     }
93446   }
93447
93448   jresult = (void *)result;
93449   return jresult;
93450 }
93451
93452
93453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93454   void * jresult ;
93455   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93456   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93457
93458   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93459   if (!arg1) {
93460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93461     return 0;
93462   }
93463   {
93464     try {
93465       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);
93466     } catch (std::out_of_range& e) {
93467       {
93468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93469       };
93470     } catch (std::exception& e) {
93471       {
93472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93473       };
93474     } catch (Dali::DaliException e) {
93475       {
93476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93477       };
93478     } catch (...) {
93479       {
93480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93481       };
93482     }
93483   }
93484
93485   jresult = (void *)result;
93486   return jresult;
93487 }
93488
93489
93490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93491   void * jresult ;
93492   int arg1 ;
93493   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93494
93495   arg1 = (int)jarg1;
93496   {
93497     try {
93498       try {
93499         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);
93500       }
93501       catch(std::out_of_range &_e) {
93502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93503         return 0;
93504       }
93505
93506     } catch (std::out_of_range& e) {
93507       {
93508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93509       };
93510     } catch (std::exception& e) {
93511       {
93512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93513       };
93514     } catch (Dali::DaliException e) {
93515       {
93516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93517       };
93518     } catch (...) {
93519       {
93520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93521       };
93522     }
93523   }
93524
93525   jresult = (void *)result;
93526   return jresult;
93527 }
93528
93529
93530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93531   void * jresult ;
93532   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93533   int arg2 ;
93534   std::pair< unsigned int,Dali::Actor > result;
93535
93536   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93537   arg2 = (int)jarg2;
93538   {
93539     try {
93540       try {
93541         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93542       }
93543       catch(std::out_of_range &_e) {
93544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93545         return 0;
93546       }
93547
93548     } catch (std::out_of_range& e) {
93549       {
93550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93551       };
93552     } catch (std::exception& e) {
93553       {
93554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93555       };
93556     } catch (Dali::DaliException e) {
93557       {
93558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93559       };
93560     } catch (...) {
93561       {
93562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93563       };
93564     }
93565   }
93566
93567   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93568   return jresult;
93569 }
93570
93571
93572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93573   void * jresult ;
93574   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93575   int arg2 ;
93576   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93577
93578   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93579   arg2 = (int)jarg2;
93580   {
93581     try {
93582       try {
93583         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93584       }
93585       catch(std::out_of_range &_e) {
93586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93587         return 0;
93588       }
93589
93590     } catch (std::out_of_range& e) {
93591       {
93592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93593       };
93594     } catch (std::exception& e) {
93595       {
93596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93597       };
93598     } catch (Dali::DaliException e) {
93599       {
93600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93601       };
93602     } catch (...) {
93603       {
93604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93605       };
93606     }
93607   }
93608
93609   jresult = (void *)result;
93610   return jresult;
93611 }
93612
93613
93614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93615   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93616   int arg2 ;
93617   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93618
93619   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93620   arg2 = (int)jarg2;
93621   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93622   if (!arg3) {
93623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93624     return ;
93625   }
93626   {
93627     try {
93628       try {
93629         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);
93630       }
93631       catch(std::out_of_range &_e) {
93632         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93633         return ;
93634       }
93635
93636     } catch (std::out_of_range& e) {
93637       {
93638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93639       };
93640     } catch (std::exception& e) {
93641       {
93642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93643       };
93644     } catch (Dali::DaliException e) {
93645       {
93646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93647       };
93648     } catch (...) {
93649       {
93650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93651       };
93652     }
93653   }
93654
93655 }
93656
93657
93658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93659   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93660   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93661
93662   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93663   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93664   if (!arg2) {
93665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93666     return ;
93667   }
93668   {
93669     try {
93670       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);
93671     } catch (std::out_of_range& e) {
93672       {
93673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93674       };
93675     } catch (std::exception& e) {
93676       {
93677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93678       };
93679     } catch (Dali::DaliException e) {
93680       {
93681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93682       };
93683     } catch (...) {
93684       {
93685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93686       };
93687     }
93688   }
93689
93690 }
93691
93692
93693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93694   void * jresult ;
93695   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93696   int arg2 ;
93697   int arg3 ;
93698   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93699
93700   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93701   arg2 = (int)jarg2;
93702   arg3 = (int)jarg3;
93703   {
93704     try {
93705       try {
93706         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);
93707       }
93708       catch(std::out_of_range &_e) {
93709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93710         return 0;
93711       }
93712       catch(std::invalid_argument &_e) {
93713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93714         return 0;
93715       }
93716
93717     } catch (std::out_of_range& e) {
93718       {
93719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93720       };
93721     } catch (std::exception& e) {
93722       {
93723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93724       };
93725     } catch (Dali::DaliException e) {
93726       {
93727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93728       };
93729     } catch (...) {
93730       {
93731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93732       };
93733     }
93734   }
93735
93736   jresult = (void *)result;
93737   return jresult;
93738 }
93739
93740
93741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93742   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93743   int arg2 ;
93744   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93745
93746   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93747   arg2 = (int)jarg2;
93748   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93749   if (!arg3) {
93750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93751     return ;
93752   }
93753   {
93754     try {
93755       try {
93756         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);
93757       }
93758       catch(std::out_of_range &_e) {
93759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93760         return ;
93761       }
93762
93763     } catch (std::out_of_range& e) {
93764       {
93765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93766       };
93767     } catch (std::exception& e) {
93768       {
93769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93770       };
93771     } catch (Dali::DaliException e) {
93772       {
93773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93774       };
93775     } catch (...) {
93776       {
93777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93778       };
93779     }
93780   }
93781
93782 }
93783
93784
93785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93786   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93787   int arg2 ;
93788   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93789
93790   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93791   arg2 = (int)jarg2;
93792   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93793   if (!arg3) {
93794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93795     return ;
93796   }
93797   {
93798     try {
93799       try {
93800         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);
93801       }
93802       catch(std::out_of_range &_e) {
93803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93804         return ;
93805       }
93806
93807     } catch (std::out_of_range& e) {
93808       {
93809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93810       };
93811     } catch (std::exception& e) {
93812       {
93813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93814       };
93815     } catch (Dali::DaliException e) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93818       };
93819     } catch (...) {
93820       {
93821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93822       };
93823     }
93824   }
93825
93826 }
93827
93828
93829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93830   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93831   int arg2 ;
93832
93833   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93834   arg2 = (int)jarg2;
93835   {
93836     try {
93837       try {
93838         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93839       }
93840       catch(std::out_of_range &_e) {
93841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93842         return ;
93843       }
93844
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93852       };
93853     } catch (Dali::DaliException e) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93856       };
93857     } catch (...) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93860       };
93861     }
93862   }
93863
93864 }
93865
93866
93867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93868   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93869   int arg2 ;
93870   int arg3 ;
93871
93872   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93873   arg2 = (int)jarg2;
93874   arg3 = (int)jarg3;
93875   {
93876     try {
93877       try {
93878         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93879       }
93880       catch(std::out_of_range &_e) {
93881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93882         return ;
93883       }
93884       catch(std::invalid_argument &_e) {
93885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93886         return ;
93887       }
93888
93889     } catch (std::out_of_range& e) {
93890       {
93891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93892       };
93893     } catch (std::exception& e) {
93894       {
93895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93896       };
93897     } catch (Dali::DaliException e) {
93898       {
93899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93900       };
93901     } catch (...) {
93902       {
93903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93904       };
93905     }
93906   }
93907
93908 }
93909
93910
93911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93912   void * jresult ;
93913   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93914   int arg2 ;
93915   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93916
93917   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93918   if (!arg1) {
93919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93920     return 0;
93921   }
93922   arg2 = (int)jarg2;
93923   {
93924     try {
93925       try {
93926         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);
93927       }
93928       catch(std::out_of_range &_e) {
93929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93930         return 0;
93931       }
93932
93933     } catch (std::out_of_range& e) {
93934       {
93935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93936       };
93937     } catch (std::exception& e) {
93938       {
93939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93940       };
93941     } catch (Dali::DaliException e) {
93942       {
93943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93944       };
93945     } catch (...) {
93946       {
93947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93948       };
93949     }
93950   }
93951
93952   jresult = (void *)result;
93953   return jresult;
93954 }
93955
93956
93957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93958   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93959
93960   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93961   {
93962     try {
93963       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93964     } catch (std::out_of_range& e) {
93965       {
93966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93967       };
93968     } catch (std::exception& e) {
93969       {
93970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93971       };
93972     } catch (Dali::DaliException e) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93975       };
93976     } catch (...) {
93977       {
93978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93979       };
93980     }
93981   }
93982
93983 }
93984
93985
93986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93987   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93988   int arg2 ;
93989   int arg3 ;
93990
93991   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93992   arg2 = (int)jarg2;
93993   arg3 = (int)jarg3;
93994   {
93995     try {
93996       try {
93997         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93998       }
93999       catch(std::out_of_range &_e) {
94000         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94001         return ;
94002       }
94003       catch(std::invalid_argument &_e) {
94004         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94005         return ;
94006       }
94007
94008     } catch (std::out_of_range& e) {
94009       {
94010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94011       };
94012     } catch (std::exception& e) {
94013       {
94014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94015       };
94016     } catch (Dali::DaliException e) {
94017       {
94018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94019       };
94020     } catch (...) {
94021       {
94022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94023       };
94024     }
94025   }
94026
94027 }
94028
94029
94030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94031   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94032   int arg2 ;
94033   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94034
94035   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94036   arg2 = (int)jarg2;
94037   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94038   if (!arg3) {
94039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94040     return ;
94041   }
94042   {
94043     try {
94044       try {
94045         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);
94046       }
94047       catch(std::out_of_range &_e) {
94048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94049         return ;
94050       }
94051
94052     } catch (std::out_of_range& e) {
94053       {
94054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94055       };
94056     } catch (std::exception& e) {
94057       {
94058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94059       };
94060     } catch (Dali::DaliException e) {
94061       {
94062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94063       };
94064     } catch (...) {
94065       {
94066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94067       };
94068     }
94069   }
94070
94071 }
94072
94073
94074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94075   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94076
94077   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94078   {
94079     try {
94080       delete arg1;
94081     } catch (std::out_of_range& e) {
94082       {
94083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94084       };
94085     } catch (std::exception& e) {
94086       {
94087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (Dali::DaliException e) {
94090       {
94091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94092       };
94093     } catch (...) {
94094       {
94095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94096       };
94097     }
94098   }
94099
94100 }
94101
94102
94103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94104   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94105
94106   arg1 = (std::vector< Dali::Actor > *)jarg1;
94107   {
94108     try {
94109       (arg1)->clear();
94110     } catch (std::out_of_range& e) {
94111       {
94112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94113       };
94114     } catch (std::exception& e) {
94115       {
94116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94117       };
94118     } catch (Dali::DaliException e) {
94119       {
94120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94121       };
94122     } catch (...) {
94123       {
94124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94125       };
94126     }
94127   }
94128
94129 }
94130
94131
94132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94133   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94134   Dali::Actor *arg2 = 0 ;
94135
94136   arg1 = (std::vector< Dali::Actor > *)jarg1;
94137   arg2 = (Dali::Actor *)jarg2;
94138   if (!arg2) {
94139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94140     return ;
94141   }
94142   {
94143     try {
94144       (arg1)->push_back((Dali::Actor const &)*arg2);
94145     } catch (std::out_of_range& e) {
94146       {
94147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94148       };
94149     } catch (std::exception& e) {
94150       {
94151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94152       };
94153     } catch (Dali::DaliException e) {
94154       {
94155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94156       };
94157     } catch (...) {
94158       {
94159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94160       };
94161     }
94162   }
94163
94164 }
94165
94166
94167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94168   unsigned long jresult ;
94169   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94170   std::vector< Dali::Actor >::size_type result;
94171
94172   arg1 = (std::vector< Dali::Actor > *)jarg1;
94173   {
94174     try {
94175       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94176     } catch (std::out_of_range& e) {
94177       {
94178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94179       };
94180     } catch (std::exception& e) {
94181       {
94182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94183       };
94184     } catch (Dali::DaliException e) {
94185       {
94186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94187       };
94188     } catch (...) {
94189       {
94190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94191       };
94192     }
94193   }
94194
94195   jresult = (unsigned long)result;
94196   return jresult;
94197 }
94198
94199
94200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94201   unsigned long jresult ;
94202   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94203   std::vector< Dali::Actor >::size_type result;
94204
94205   arg1 = (std::vector< Dali::Actor > *)jarg1;
94206   {
94207     try {
94208       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94209     } catch (std::out_of_range& e) {
94210       {
94211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94212       };
94213     } catch (std::exception& e) {
94214       {
94215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94216       };
94217     } catch (Dali::DaliException e) {
94218       {
94219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94220       };
94221     } catch (...) {
94222       {
94223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94224       };
94225     }
94226   }
94227
94228   jresult = (unsigned long)result;
94229   return jresult;
94230 }
94231
94232
94233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94234   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94235   std::vector< Dali::Actor >::size_type arg2 ;
94236
94237   arg1 = (std::vector< Dali::Actor > *)jarg1;
94238   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94239   {
94240     try {
94241       (arg1)->reserve(arg2);
94242     } catch (std::out_of_range& e) {
94243       {
94244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94245       };
94246     } catch (std::exception& e) {
94247       {
94248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94249       };
94250     } catch (Dali::DaliException e) {
94251       {
94252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94253       };
94254     } catch (...) {
94255       {
94256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94257       };
94258     }
94259   }
94260
94261 }
94262
94263
94264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94265   void * jresult ;
94266   std::vector< Dali::Actor > *result = 0 ;
94267
94268   {
94269     try {
94270       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94271     } catch (std::out_of_range& e) {
94272       {
94273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94274       };
94275     } catch (std::exception& e) {
94276       {
94277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94278       };
94279     } catch (Dali::DaliException e) {
94280       {
94281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94282       };
94283     } catch (...) {
94284       {
94285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94286       };
94287     }
94288   }
94289
94290   jresult = (void *)result;
94291   return jresult;
94292 }
94293
94294
94295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94296   void * jresult ;
94297   std::vector< Dali::Actor > *arg1 = 0 ;
94298   std::vector< Dali::Actor > *result = 0 ;
94299
94300   arg1 = (std::vector< Dali::Actor > *)jarg1;
94301   if (!arg1) {
94302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94303     return 0;
94304   }
94305   {
94306     try {
94307       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94308     } catch (std::out_of_range& e) {
94309       {
94310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94311       };
94312     } catch (std::exception& e) {
94313       {
94314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94315       };
94316     } catch (Dali::DaliException e) {
94317       {
94318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94319       };
94320     } catch (...) {
94321       {
94322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94323       };
94324     }
94325   }
94326
94327   jresult = (void *)result;
94328   return jresult;
94329 }
94330
94331
94332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94333   void * jresult ;
94334   int arg1 ;
94335   std::vector< Dali::Actor > *result = 0 ;
94336
94337   arg1 = (int)jarg1;
94338   {
94339     try {
94340       try {
94341         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94342       }
94343       catch(std::out_of_range &_e) {
94344         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94345         return 0;
94346       }
94347
94348     } catch (std::out_of_range& e) {
94349       {
94350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94351       };
94352     } catch (std::exception& e) {
94353       {
94354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94355       };
94356     } catch (Dali::DaliException e) {
94357       {
94358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94359       };
94360     } catch (...) {
94361       {
94362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94363       };
94364     }
94365   }
94366
94367   jresult = (void *)result;
94368   return jresult;
94369 }
94370
94371
94372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94373   void * jresult ;
94374   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94375   int arg2 ;
94376   Dali::Actor result;
94377
94378   arg1 = (std::vector< Dali::Actor > *)jarg1;
94379   arg2 = (int)jarg2;
94380   {
94381     try {
94382       try {
94383         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94384       }
94385       catch(std::out_of_range &_e) {
94386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94387         return 0;
94388       }
94389
94390     } catch (std::out_of_range& e) {
94391       {
94392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94393       };
94394     } catch (std::exception& e) {
94395       {
94396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94397       };
94398     } catch (Dali::DaliException e) {
94399       {
94400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94401       };
94402     } catch (...) {
94403       {
94404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94405       };
94406     }
94407   }
94408
94409   jresult = new Dali::Actor((const Dali::Actor &)result);
94410   return jresult;
94411 }
94412
94413
94414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94415   void * jresult ;
94416   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94417   int arg2 ;
94418   Dali::Actor *result = 0 ;
94419
94420   arg1 = (std::vector< Dali::Actor > *)jarg1;
94421   arg2 = (int)jarg2;
94422   {
94423     try {
94424       try {
94425         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94426       }
94427       catch(std::out_of_range &_e) {
94428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94429         return 0;
94430       }
94431
94432     } catch (std::out_of_range& e) {
94433       {
94434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94435       };
94436     } catch (std::exception& e) {
94437       {
94438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94439       };
94440     } catch (Dali::DaliException e) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94443       };
94444     } catch (...) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94447       };
94448     }
94449   }
94450
94451   jresult = (void *)result;
94452   return jresult;
94453 }
94454
94455
94456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94457   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94458   int arg2 ;
94459   Dali::Actor *arg3 = 0 ;
94460
94461   arg1 = (std::vector< Dali::Actor > *)jarg1;
94462   arg2 = (int)jarg2;
94463   arg3 = (Dali::Actor *)jarg3;
94464   if (!arg3) {
94465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94466     return ;
94467   }
94468   {
94469     try {
94470       try {
94471         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94472       }
94473       catch(std::out_of_range &_e) {
94474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94475         return ;
94476       }
94477
94478     } catch (std::out_of_range& e) {
94479       {
94480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94481       };
94482     } catch (std::exception& e) {
94483       {
94484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94485       };
94486     } catch (Dali::DaliException e) {
94487       {
94488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94489       };
94490     } catch (...) {
94491       {
94492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94493       };
94494     }
94495   }
94496
94497 }
94498
94499
94500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94501   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94502   std::vector< Dali::Actor > *arg2 = 0 ;
94503
94504   arg1 = (std::vector< Dali::Actor > *)jarg1;
94505   arg2 = (std::vector< Dali::Actor > *)jarg2;
94506   if (!arg2) {
94507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94508     return ;
94509   }
94510   {
94511     try {
94512       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94513     } catch (std::out_of_range& e) {
94514       {
94515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94516       };
94517     } catch (std::exception& e) {
94518       {
94519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94520       };
94521     } catch (Dali::DaliException e) {
94522       {
94523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94524       };
94525     } catch (...) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94528       };
94529     }
94530   }
94531
94532 }
94533
94534
94535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94536   void * jresult ;
94537   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94538   int arg2 ;
94539   int arg3 ;
94540   std::vector< Dali::Actor > *result = 0 ;
94541
94542   arg1 = (std::vector< Dali::Actor > *)jarg1;
94543   arg2 = (int)jarg2;
94544   arg3 = (int)jarg3;
94545   {
94546     try {
94547       try {
94548         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94549       }
94550       catch(std::out_of_range &_e) {
94551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94552         return 0;
94553       }
94554       catch(std::invalid_argument &_e) {
94555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94556         return 0;
94557       }
94558
94559     } catch (std::out_of_range& e) {
94560       {
94561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94562       };
94563     } catch (std::exception& e) {
94564       {
94565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94566       };
94567     } catch (Dali::DaliException e) {
94568       {
94569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94570       };
94571     } catch (...) {
94572       {
94573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94574       };
94575     }
94576   }
94577
94578   jresult = (void *)result;
94579   return jresult;
94580 }
94581
94582
94583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94584   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94585   int arg2 ;
94586   Dali::Actor *arg3 = 0 ;
94587
94588   arg1 = (std::vector< Dali::Actor > *)jarg1;
94589   arg2 = (int)jarg2;
94590   arg3 = (Dali::Actor *)jarg3;
94591   if (!arg3) {
94592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94593     return ;
94594   }
94595   {
94596     try {
94597       try {
94598         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94599       }
94600       catch(std::out_of_range &_e) {
94601         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94602         return ;
94603       }
94604
94605     } catch (std::out_of_range& e) {
94606       {
94607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94608       };
94609     } catch (std::exception& e) {
94610       {
94611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94612       };
94613     } catch (Dali::DaliException e) {
94614       {
94615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94616       };
94617     } catch (...) {
94618       {
94619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94620       };
94621     }
94622   }
94623
94624 }
94625
94626
94627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94628   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94629   int arg2 ;
94630   std::vector< Dali::Actor > *arg3 = 0 ;
94631
94632   arg1 = (std::vector< Dali::Actor > *)jarg1;
94633   arg2 = (int)jarg2;
94634   arg3 = (std::vector< Dali::Actor > *)jarg3;
94635   if (!arg3) {
94636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94637     return ;
94638   }
94639   {
94640     try {
94641       try {
94642         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94643       }
94644       catch(std::out_of_range &_e) {
94645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94646         return ;
94647       }
94648
94649     } catch (std::out_of_range& e) {
94650       {
94651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94652       };
94653     } catch (std::exception& e) {
94654       {
94655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94656       };
94657     } catch (Dali::DaliException e) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94660       };
94661     } catch (...) {
94662       {
94663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94664       };
94665     }
94666   }
94667
94668 }
94669
94670
94671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94672   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94673   int arg2 ;
94674
94675   arg1 = (std::vector< Dali::Actor > *)jarg1;
94676   arg2 = (int)jarg2;
94677   {
94678     try {
94679       try {
94680         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94681       }
94682       catch(std::out_of_range &_e) {
94683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94684         return ;
94685       }
94686
94687     } catch (std::out_of_range& e) {
94688       {
94689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94690       };
94691     } catch (std::exception& e) {
94692       {
94693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94694       };
94695     } catch (Dali::DaliException e) {
94696       {
94697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94698       };
94699     } catch (...) {
94700       {
94701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94702       };
94703     }
94704   }
94705
94706 }
94707
94708
94709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94710   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94711   int arg2 ;
94712   int arg3 ;
94713
94714   arg1 = (std::vector< Dali::Actor > *)jarg1;
94715   arg2 = (int)jarg2;
94716   arg3 = (int)jarg3;
94717   {
94718     try {
94719       try {
94720         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94721       }
94722       catch(std::out_of_range &_e) {
94723         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94724         return ;
94725       }
94726       catch(std::invalid_argument &_e) {
94727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94728         return ;
94729       }
94730
94731     } catch (std::out_of_range& e) {
94732       {
94733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94734       };
94735     } catch (std::exception& e) {
94736       {
94737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94738       };
94739     } catch (Dali::DaliException e) {
94740       {
94741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94742       };
94743     } catch (...) {
94744       {
94745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94746       };
94747     }
94748   }
94749
94750 }
94751
94752
94753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94754   void * jresult ;
94755   Dali::Actor *arg1 = 0 ;
94756   int arg2 ;
94757   std::vector< Dali::Actor > *result = 0 ;
94758
94759   arg1 = (Dali::Actor *)jarg1;
94760   if (!arg1) {
94761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94762     return 0;
94763   }
94764   arg2 = (int)jarg2;
94765   {
94766     try {
94767       try {
94768         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94769       }
94770       catch(std::out_of_range &_e) {
94771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94772         return 0;
94773       }
94774
94775     } catch (std::out_of_range& e) {
94776       {
94777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94778       };
94779     } catch (std::exception& e) {
94780       {
94781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94782       };
94783     } catch (Dali::DaliException e) {
94784       {
94785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94786       };
94787     } catch (...) {
94788       {
94789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94790       };
94791     }
94792   }
94793
94794   jresult = (void *)result;
94795   return jresult;
94796 }
94797
94798
94799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94800   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94801
94802   arg1 = (std::vector< Dali::Actor > *)jarg1;
94803   {
94804     try {
94805       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94806     } catch (std::out_of_range& e) {
94807       {
94808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94809       };
94810     } catch (std::exception& e) {
94811       {
94812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94813       };
94814     } catch (Dali::DaliException e) {
94815       {
94816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94817       };
94818     } catch (...) {
94819       {
94820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94821       };
94822     }
94823   }
94824
94825 }
94826
94827
94828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94829   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94830   int arg2 ;
94831   int arg3 ;
94832
94833   arg1 = (std::vector< Dali::Actor > *)jarg1;
94834   arg2 = (int)jarg2;
94835   arg3 = (int)jarg3;
94836   {
94837     try {
94838       try {
94839         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94840       }
94841       catch(std::out_of_range &_e) {
94842         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94843         return ;
94844       }
94845       catch(std::invalid_argument &_e) {
94846         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94847         return ;
94848       }
94849
94850     } catch (std::out_of_range& e) {
94851       {
94852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94853       };
94854     } catch (std::exception& e) {
94855       {
94856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94857       };
94858     } catch (Dali::DaliException e) {
94859       {
94860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94861       };
94862     } catch (...) {
94863       {
94864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94865       };
94866     }
94867   }
94868
94869 }
94870
94871
94872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94873   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94874   int arg2 ;
94875   std::vector< Dali::Actor > *arg3 = 0 ;
94876
94877   arg1 = (std::vector< Dali::Actor > *)jarg1;
94878   arg2 = (int)jarg2;
94879   arg3 = (std::vector< Dali::Actor > *)jarg3;
94880   if (!arg3) {
94881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94882     return ;
94883   }
94884   {
94885     try {
94886       try {
94887         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94888       }
94889       catch(std::out_of_range &_e) {
94890         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94891         return ;
94892       }
94893
94894     } catch (std::out_of_range& e) {
94895       {
94896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94897       };
94898     } catch (std::exception& e) {
94899       {
94900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94901       };
94902     } catch (Dali::DaliException e) {
94903       {
94904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94905       };
94906     } catch (...) {
94907       {
94908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94909       };
94910     }
94911   }
94912
94913 }
94914
94915
94916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94917   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94918
94919   arg1 = (std::vector< Dali::Actor > *)jarg1;
94920   {
94921     try {
94922       delete arg1;
94923     } catch (std::out_of_range& e) {
94924       {
94925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94926       };
94927     } catch (std::exception& e) {
94928       {
94929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94930       };
94931     } catch (Dali::DaliException e) {
94932       {
94933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94934       };
94935     } catch (...) {
94936       {
94937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94938       };
94939     }
94940   }
94941
94942 }
94943
94944
94945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94946   unsigned int jresult ;
94947   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94948   bool result;
94949
94950   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94951   {
94952     try {
94953       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94954     } catch (std::out_of_range& e) {
94955       {
94956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94957       };
94958     } catch (std::exception& e) {
94959       {
94960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94961       };
94962     } catch (Dali::DaliException e) {
94963       {
94964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94965       };
94966     } catch (...) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94969       };
94970     }
94971   }
94972
94973   jresult = result;
94974   return jresult;
94975 }
94976
94977
94978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94979   unsigned long jresult ;
94980   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94981   std::size_t result;
94982
94983   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94984   {
94985     try {
94986       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94987     } catch (std::out_of_range& e) {
94988       {
94989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94990       };
94991     } catch (std::exception& e) {
94992       {
94993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94994       };
94995     } catch (Dali::DaliException e) {
94996       {
94997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94998       };
94999     } catch (...) {
95000       {
95001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95002       };
95003     }
95004   }
95005
95006   jresult = (unsigned long)result;
95007   return jresult;
95008 }
95009
95010
95011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95012   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95013   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95014
95015   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95016   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95017   {
95018     try {
95019       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95020     } catch (std::out_of_range& e) {
95021       {
95022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95023       };
95024     } catch (std::exception& e) {
95025       {
95026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95027       };
95028     } catch (Dali::DaliException e) {
95029       {
95030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95031       };
95032     } catch (...) {
95033       {
95034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95035       };
95036     }
95037   }
95038
95039 }
95040
95041
95042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95043   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95044   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95045
95046   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95047   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95048   {
95049     try {
95050       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95051     } catch (std::out_of_range& e) {
95052       {
95053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95054       };
95055     } catch (std::exception& e) {
95056       {
95057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95058       };
95059     } catch (Dali::DaliException e) {
95060       {
95061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95062       };
95063     } catch (...) {
95064       {
95065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95066       };
95067     }
95068   }
95069
95070 }
95071
95072
95073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95074   unsigned int jresult ;
95075   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95076   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95077   bool result;
95078
95079   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95080   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95081   if (!arg2) {
95082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95083     return 0;
95084   }
95085   {
95086     try {
95087       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95088     } catch (std::out_of_range& e) {
95089       {
95090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95091       };
95092     } catch (std::exception& e) {
95093       {
95094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95095       };
95096     } catch (Dali::DaliException e) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95099       };
95100     } catch (...) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95103       };
95104     }
95105   }
95106
95107   jresult = result;
95108   return jresult;
95109 }
95110
95111
95112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95113   void * jresult ;
95114   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95115
95116   {
95117     try {
95118       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95119     } catch (std::out_of_range& e) {
95120       {
95121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95122       };
95123     } catch (std::exception& e) {
95124       {
95125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95126       };
95127     } catch (Dali::DaliException e) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95130       };
95131     } catch (...) {
95132       {
95133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95134       };
95135     }
95136   }
95137
95138   jresult = (void *)result;
95139   return jresult;
95140 }
95141
95142
95143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95144   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95145
95146   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95147   {
95148     try {
95149       delete arg1;
95150     } catch (std::out_of_range& e) {
95151       {
95152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95153       };
95154     } catch (std::exception& e) {
95155       {
95156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95157       };
95158     } catch (Dali::DaliException e) {
95159       {
95160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95161       };
95162     } catch (...) {
95163       {
95164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95165       };
95166     }
95167   }
95168
95169 }
95170
95171
95172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95173   unsigned int jresult ;
95174   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95175   bool result;
95176
95177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95178   {
95179     try {
95180       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);
95181     } catch (std::out_of_range& e) {
95182       {
95183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95184       };
95185     } catch (std::exception& e) {
95186       {
95187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95188       };
95189     } catch (Dali::DaliException e) {
95190       {
95191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95192       };
95193     } catch (...) {
95194       {
95195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95196       };
95197     }
95198   }
95199
95200   jresult = result;
95201   return jresult;
95202 }
95203
95204
95205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95206   unsigned long jresult ;
95207   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95208   std::size_t result;
95209
95210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95211   {
95212     try {
95213       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);
95214     } catch (std::out_of_range& e) {
95215       {
95216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (std::exception& e) {
95219       {
95220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (Dali::DaliException e) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95225       };
95226     } catch (...) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95229       };
95230     }
95231   }
95232
95233   jresult = (unsigned long)result;
95234   return jresult;
95235 }
95236
95237
95238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95239   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95240   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95241
95242   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95243   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95244   {
95245     try {
95246       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95247     } catch (std::out_of_range& e) {
95248       {
95249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95250       };
95251     } catch (std::exception& e) {
95252       {
95253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95254       };
95255     } catch (Dali::DaliException e) {
95256       {
95257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95258       };
95259     } catch (...) {
95260       {
95261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95262       };
95263     }
95264   }
95265
95266 }
95267
95268
95269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95270   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95271   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95272
95273   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95274   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95275   {
95276     try {
95277       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95278     } catch (std::out_of_range& e) {
95279       {
95280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95281       };
95282     } catch (std::exception& e) {
95283       {
95284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95285       };
95286     } catch (Dali::DaliException e) {
95287       {
95288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95289       };
95290     } catch (...) {
95291       {
95292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95293       };
95294     }
95295   }
95296
95297 }
95298
95299
95300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95301   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95302   Dali::Actor arg2 ;
95303   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95304   Dali::Actor *argp2 ;
95305
95306   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95307   argp2 = (Dali::Actor *)jarg2;
95308   if (!argp2) {
95309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95310     return ;
95311   }
95312   arg2 = *argp2;
95313   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95314   {
95315     try {
95316       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95317     } catch (std::out_of_range& e) {
95318       {
95319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95320       };
95321     } catch (std::exception& e) {
95322       {
95323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95324       };
95325     } catch (Dali::DaliException e) {
95326       {
95327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95328       };
95329     } catch (...) {
95330       {
95331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95332       };
95333     }
95334   }
95335
95336 }
95337
95338
95339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95340   void * jresult ;
95341   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95342
95343   {
95344     try {
95345       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
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 = (void *)result;
95366   return jresult;
95367 }
95368
95369
95370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95371   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95372
95373   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95374   {
95375     try {
95376       delete arg1;
95377     } catch (std::out_of_range& e) {
95378       {
95379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95380       };
95381     } catch (std::exception& e) {
95382       {
95383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95384       };
95385     } catch (Dali::DaliException e) {
95386       {
95387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95388       };
95389     } catch (...) {
95390       {
95391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95392       };
95393     }
95394   }
95395
95396 }
95397
95398
95399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95400   unsigned int jresult ;
95401   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95402   bool result;
95403
95404   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95405   {
95406     try {
95407       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95408     } catch (std::out_of_range& e) {
95409       {
95410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95411       };
95412     } catch (std::exception& e) {
95413       {
95414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95415       };
95416     } catch (Dali::DaliException e) {
95417       {
95418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95419       };
95420     } catch (...) {
95421       {
95422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95423       };
95424     }
95425   }
95426
95427   jresult = result;
95428   return jresult;
95429 }
95430
95431
95432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95433   unsigned long jresult ;
95434   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95435   std::size_t result;
95436
95437   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95438   {
95439     try {
95440       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95441     } catch (std::out_of_range& e) {
95442       {
95443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95444       };
95445     } catch (std::exception& e) {
95446       {
95447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95448       };
95449     } catch (Dali::DaliException e) {
95450       {
95451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95452       };
95453     } catch (...) {
95454       {
95455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95456       };
95457     }
95458   }
95459
95460   jresult = (unsigned long)result;
95461   return jresult;
95462 }
95463
95464
95465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95466   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95467   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95468
95469   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95470   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95471   {
95472     try {
95473       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95474     } catch (std::out_of_range& e) {
95475       {
95476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95477       };
95478     } catch (std::exception& e) {
95479       {
95480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95481       };
95482     } catch (Dali::DaliException e) {
95483       {
95484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95485       };
95486     } catch (...) {
95487       {
95488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95489       };
95490     }
95491   }
95492
95493 }
95494
95495
95496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95497   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95498   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95499
95500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95501   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95502   {
95503     try {
95504       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(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_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95528   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95529   Dali::Actor arg2 ;
95530   Dali::Actor arg3 ;
95531   Dali::Actor *argp2 ;
95532   Dali::Actor *argp3 ;
95533
95534   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95535   argp2 = (Dali::Actor *)jarg2;
95536   if (!argp2) {
95537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95538     return ;
95539   }
95540   arg2 = *argp2;
95541   argp3 = (Dali::Actor *)jarg3;
95542   if (!argp3) {
95543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95544     return ;
95545   }
95546   arg3 = *argp3;
95547   {
95548     try {
95549       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95550     } catch (std::out_of_range& e) {
95551       {
95552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95553       };
95554     } catch (std::exception& e) {
95555       {
95556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95557       };
95558     } catch (Dali::DaliException e) {
95559       {
95560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95561       };
95562     } catch (...) {
95563       {
95564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95565       };
95566     }
95567   }
95568
95569 }
95570
95571
95572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95573   void * jresult ;
95574   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95575
95576   {
95577     try {
95578       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95579     } catch (std::out_of_range& e) {
95580       {
95581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95582       };
95583     } catch (std::exception& e) {
95584       {
95585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95586       };
95587     } catch (Dali::DaliException e) {
95588       {
95589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95590       };
95591     } catch (...) {
95592       {
95593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95594       };
95595     }
95596   }
95597
95598   jresult = (void *)result;
95599   return jresult;
95600 }
95601
95602
95603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95604   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95605
95606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95607   {
95608     try {
95609       delete arg1;
95610     } catch (std::out_of_range& e) {
95611       {
95612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95613       };
95614     } catch (std::exception& e) {
95615       {
95616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95617       };
95618     } catch (Dali::DaliException e) {
95619       {
95620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95621       };
95622     } catch (...) {
95623       {
95624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95625       };
95626     }
95627   }
95628
95629 }
95630
95631
95632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95633   unsigned int jresult ;
95634   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95635   bool result;
95636
95637   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95638   {
95639     try {
95640       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95641     } catch (std::out_of_range& e) {
95642       {
95643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95644       };
95645     } catch (std::exception& e) {
95646       {
95647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95648       };
95649     } catch (Dali::DaliException e) {
95650       {
95651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95652       };
95653     } catch (...) {
95654       {
95655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95656       };
95657     }
95658   }
95659
95660   jresult = result;
95661   return jresult;
95662 }
95663
95664
95665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95666   unsigned long jresult ;
95667   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95668   std::size_t result;
95669
95670   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95671   {
95672     try {
95673       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95674     } catch (std::out_of_range& e) {
95675       {
95676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95677       };
95678     } catch (std::exception& e) {
95679       {
95680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95681       };
95682     } catch (Dali::DaliException e) {
95683       {
95684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95685       };
95686     } catch (...) {
95687       {
95688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95689       };
95690     }
95691   }
95692
95693   jresult = (unsigned long)result;
95694   return jresult;
95695 }
95696
95697
95698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95699   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95700   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95701
95702   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95703   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95704   {
95705     try {
95706       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95707     } catch (std::out_of_range& e) {
95708       {
95709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95710       };
95711     } catch (std::exception& e) {
95712       {
95713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95714       };
95715     } catch (Dali::DaliException e) {
95716       {
95717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95718       };
95719     } catch (...) {
95720       {
95721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95722       };
95723     }
95724   }
95725
95726 }
95727
95728
95729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95730   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95731   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95732
95733   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95734   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95735   {
95736     try {
95737       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95738     } catch (std::out_of_range& e) {
95739       {
95740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95741       };
95742     } catch (std::exception& e) {
95743       {
95744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95745       };
95746     } catch (Dali::DaliException e) {
95747       {
95748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95749       };
95750     } catch (...) {
95751       {
95752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95753       };
95754     }
95755   }
95756
95757 }
95758
95759
95760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95761   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95762   Dali::Actor arg2 ;
95763   bool arg3 ;
95764   Dali::Actor *argp2 ;
95765
95766   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95767   argp2 = (Dali::Actor *)jarg2;
95768   if (!argp2) {
95769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95770     return ;
95771   }
95772   arg2 = *argp2;
95773   arg3 = jarg3 ? true : false;
95774   {
95775     try {
95776       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95777     } catch (std::out_of_range& e) {
95778       {
95779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95780       };
95781     } catch (std::exception& e) {
95782       {
95783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95784       };
95785     } catch (Dali::DaliException e) {
95786       {
95787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95788       };
95789     } catch (...) {
95790       {
95791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95792       };
95793     }
95794   }
95795
95796 }
95797
95798
95799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95800   void * jresult ;
95801   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95802
95803   {
95804     try {
95805       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95806     } catch (std::out_of_range& e) {
95807       {
95808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95809       };
95810     } catch (std::exception& e) {
95811       {
95812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95813       };
95814     } catch (Dali::DaliException e) {
95815       {
95816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95817       };
95818     } catch (...) {
95819       {
95820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95821       };
95822     }
95823   }
95824
95825   jresult = (void *)result;
95826   return jresult;
95827 }
95828
95829
95830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95831   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95832
95833   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95834   {
95835     try {
95836       delete arg1;
95837     } catch (std::out_of_range& e) {
95838       {
95839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95840       };
95841     } catch (std::exception& e) {
95842       {
95843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95844       };
95845     } catch (Dali::DaliException e) {
95846       {
95847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95848       };
95849     } catch (...) {
95850       {
95851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95852       };
95853     }
95854   }
95855
95856 }
95857
95858
95859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95860   unsigned int jresult ;
95861   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95862   bool result;
95863
95864   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95865   {
95866     try {
95867       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);
95868     } catch (std::out_of_range& e) {
95869       {
95870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95871       };
95872     } catch (std::exception& e) {
95873       {
95874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95875       };
95876     } catch (Dali::DaliException e) {
95877       {
95878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95879       };
95880     } catch (...) {
95881       {
95882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95883       };
95884     }
95885   }
95886
95887   jresult = result;
95888   return jresult;
95889 }
95890
95891
95892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95893   unsigned long jresult ;
95894   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95895   std::size_t result;
95896
95897   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95898   {
95899     try {
95900       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);
95901     } catch (std::out_of_range& e) {
95902       {
95903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95904       };
95905     } catch (std::exception& e) {
95906       {
95907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95908       };
95909     } catch (Dali::DaliException e) {
95910       {
95911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95912       };
95913     } catch (...) {
95914       {
95915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95916       };
95917     }
95918   }
95919
95920   jresult = (unsigned long)result;
95921   return jresult;
95922 }
95923
95924
95925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95926   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95927   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95928
95929   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95930   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95931   {
95932     try {
95933       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95934     } catch (std::out_of_range& e) {
95935       {
95936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95937       };
95938     } catch (std::exception& e) {
95939       {
95940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95941       };
95942     } catch (Dali::DaliException e) {
95943       {
95944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95945       };
95946     } catch (...) {
95947       {
95948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95949       };
95950     }
95951   }
95952
95953 }
95954
95955
95956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95957   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95958   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95959
95960   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95961   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95962   {
95963     try {
95964       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95965     } catch (std::out_of_range& e) {
95966       {
95967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95968       };
95969     } catch (std::exception& e) {
95970       {
95971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95972       };
95973     } catch (Dali::DaliException e) {
95974       {
95975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95976       };
95977     } catch (...) {
95978       {
95979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95980       };
95981     }
95982   }
95983
95984 }
95985
95986
95987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95988   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95989   Dali::Toolkit::StyleManager arg2 ;
95990   Dali::StyleChange::Type arg3 ;
95991   Dali::Toolkit::StyleManager *argp2 ;
95992
95993   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95994   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95995   if (!argp2) {
95996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95997     return ;
95998   }
95999   arg2 = *argp2;
96000   arg3 = (Dali::StyleChange::Type)jarg3;
96001   {
96002     try {
96003       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96004     } catch (std::out_of_range& e) {
96005       {
96006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96007       };
96008     } catch (std::exception& e) {
96009       {
96010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96011       };
96012     } catch (Dali::DaliException e) {
96013       {
96014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96015       };
96016     } catch (...) {
96017       {
96018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96019       };
96020     }
96021   }
96022
96023 }
96024
96025
96026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96027   void * jresult ;
96028   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96029
96030   {
96031     try {
96032       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96033     } catch (std::out_of_range& e) {
96034       {
96035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96036       };
96037     } catch (std::exception& e) {
96038       {
96039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96040       };
96041     } catch (Dali::DaliException e) {
96042       {
96043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96044       };
96045     } catch (...) {
96046       {
96047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96048       };
96049     }
96050   }
96051
96052   jresult = (void *)result;
96053   return jresult;
96054 }
96055
96056
96057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96058   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96059
96060   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96061   {
96062     try {
96063       delete arg1;
96064     } catch (std::out_of_range& e) {
96065       {
96066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96067       };
96068     } catch (std::exception& e) {
96069       {
96070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96071       };
96072     } catch (Dali::DaliException e) {
96073       {
96074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96075       };
96076     } catch (...) {
96077       {
96078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96079       };
96080     }
96081   }
96082
96083 }
96084
96085
96086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96087   unsigned int jresult ;
96088   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96089   bool result;
96090
96091   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96092   {
96093     try {
96094       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96095     } catch (std::out_of_range& e) {
96096       {
96097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96098       };
96099     } catch (std::exception& e) {
96100       {
96101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96102       };
96103     } catch (Dali::DaliException e) {
96104       {
96105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96106       };
96107     } catch (...) {
96108       {
96109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96110       };
96111     }
96112   }
96113
96114   jresult = result;
96115   return jresult;
96116 }
96117
96118
96119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96120   unsigned long jresult ;
96121   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96122   std::size_t result;
96123
96124   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96125   {
96126     try {
96127       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96128     } catch (std::out_of_range& e) {
96129       {
96130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96131       };
96132     } catch (std::exception& e) {
96133       {
96134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96135       };
96136     } catch (Dali::DaliException e) {
96137       {
96138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96139       };
96140     } catch (...) {
96141       {
96142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96143       };
96144     }
96145   }
96146
96147   jresult = (unsigned long)result;
96148   return jresult;
96149 }
96150
96151
96152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96153   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96154   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96155
96156   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96157   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96158   {
96159     try {
96160       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96161     } catch (std::out_of_range& e) {
96162       {
96163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96164       };
96165     } catch (std::exception& e) {
96166       {
96167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96168       };
96169     } catch (Dali::DaliException e) {
96170       {
96171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96172       };
96173     } catch (...) {
96174       {
96175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96176       };
96177     }
96178   }
96179
96180 }
96181
96182
96183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96184   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96185   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96186
96187   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96188   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96189   {
96190     try {
96191       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96192     } catch (std::out_of_range& e) {
96193       {
96194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96195       };
96196     } catch (std::exception& e) {
96197       {
96198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96199       };
96200     } catch (Dali::DaliException e) {
96201       {
96202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96203       };
96204     } catch (...) {
96205       {
96206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96207       };
96208     }
96209   }
96210
96211 }
96212
96213
96214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96215   unsigned int jresult ;
96216   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96217   Dali::Toolkit::Button arg2 ;
96218   Dali::Toolkit::Button *argp2 ;
96219   bool result;
96220
96221   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96222   argp2 = (Dali::Toolkit::Button *)jarg2;
96223   if (!argp2) {
96224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96225     return 0;
96226   }
96227   arg2 = *argp2;
96228   {
96229     try {
96230       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96231     } catch (std::out_of_range& e) {
96232       {
96233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96234       };
96235     } catch (std::exception& e) {
96236       {
96237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96238       };
96239     } catch (Dali::DaliException e) {
96240       {
96241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96242       };
96243     } catch (...) {
96244       {
96245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96246       };
96247     }
96248   }
96249
96250   jresult = result;
96251   return jresult;
96252 }
96253
96254
96255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96256   void * jresult ;
96257   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96258
96259   {
96260     try {
96261       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96262     } catch (std::out_of_range& e) {
96263       {
96264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96265       };
96266     } catch (std::exception& e) {
96267       {
96268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96269       };
96270     } catch (Dali::DaliException e) {
96271       {
96272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96273       };
96274     } catch (...) {
96275       {
96276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96277       };
96278     }
96279   }
96280
96281   jresult = (void *)result;
96282   return jresult;
96283 }
96284
96285
96286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96287   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96288
96289   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96290   {
96291     try {
96292       delete arg1;
96293     } catch (std::out_of_range& e) {
96294       {
96295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96296       };
96297     } catch (std::exception& e) {
96298       {
96299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96300       };
96301     } catch (Dali::DaliException e) {
96302       {
96303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96304       };
96305     } catch (...) {
96306       {
96307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96308       };
96309     }
96310   }
96311
96312 }
96313
96314
96315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96316   unsigned int jresult ;
96317   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96318   bool result;
96319
96320   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96321   {
96322     try {
96323       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96324     } catch (std::out_of_range& e) {
96325       {
96326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96327       };
96328     } catch (std::exception& e) {
96329       {
96330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96331       };
96332     } catch (Dali::DaliException e) {
96333       {
96334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96335       };
96336     } catch (...) {
96337       {
96338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96339       };
96340     }
96341   }
96342
96343   jresult = result;
96344   return jresult;
96345 }
96346
96347
96348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96349   unsigned long jresult ;
96350   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96351   std::size_t result;
96352
96353   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96354   {
96355     try {
96356       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96357     } catch (std::out_of_range& e) {
96358       {
96359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96360       };
96361     } catch (std::exception& e) {
96362       {
96363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96364       };
96365     } catch (Dali::DaliException e) {
96366       {
96367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96368       };
96369     } catch (...) {
96370       {
96371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96372       };
96373     }
96374   }
96375
96376   jresult = (unsigned long)result;
96377   return jresult;
96378 }
96379
96380
96381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96382   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96383   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96384
96385   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96386   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96387   {
96388     try {
96389       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96390     } catch (std::out_of_range& e) {
96391       {
96392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96393       };
96394     } catch (std::exception& e) {
96395       {
96396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96397       };
96398     } catch (Dali::DaliException e) {
96399       {
96400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96401       };
96402     } catch (...) {
96403       {
96404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96405       };
96406     }
96407   }
96408
96409 }
96410
96411
96412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96413   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96414   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96415
96416   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96417   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96418   {
96419     try {
96420       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96421     } catch (std::out_of_range& e) {
96422       {
96423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96424       };
96425     } catch (std::exception& e) {
96426       {
96427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96428       };
96429     } catch (Dali::DaliException e) {
96430       {
96431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96432       };
96433     } catch (...) {
96434       {
96435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96436       };
96437     }
96438   }
96439
96440 }
96441
96442
96443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96444   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96445   Dali::Toolkit::GaussianBlurView arg2 ;
96446   Dali::Toolkit::GaussianBlurView *argp2 ;
96447
96448   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96449   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96450   if (!argp2) {
96451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96452     return ;
96453   }
96454   arg2 = *argp2;
96455   {
96456     try {
96457       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96458     } catch (std::out_of_range& e) {
96459       {
96460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96461       };
96462     } catch (std::exception& e) {
96463       {
96464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96465       };
96466     } catch (Dali::DaliException e) {
96467       {
96468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96469       };
96470     } catch (...) {
96471       {
96472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96473       };
96474     }
96475   }
96476
96477 }
96478
96479
96480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96481   void * jresult ;
96482   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96483
96484   {
96485     try {
96486       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96487     } catch (std::out_of_range& e) {
96488       {
96489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96490       };
96491     } catch (std::exception& e) {
96492       {
96493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96494       };
96495     } catch (Dali::DaliException e) {
96496       {
96497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96498       };
96499     } catch (...) {
96500       {
96501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96502       };
96503     }
96504   }
96505
96506   jresult = (void *)result;
96507   return jresult;
96508 }
96509
96510
96511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96512   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96513
96514   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96515   {
96516     try {
96517       delete arg1;
96518     } catch (std::out_of_range& e) {
96519       {
96520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96521       };
96522     } catch (std::exception& e) {
96523       {
96524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96525       };
96526     } catch (Dali::DaliException e) {
96527       {
96528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96529       };
96530     } catch (...) {
96531       {
96532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96533       };
96534     }
96535   }
96536
96537 }
96538
96539
96540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96541   unsigned int jresult ;
96542   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96543   bool result;
96544
96545   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96546   {
96547     try {
96548       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);
96549     } catch (std::out_of_range& e) {
96550       {
96551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96552       };
96553     } catch (std::exception& e) {
96554       {
96555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96556       };
96557     } catch (Dali::DaliException e) {
96558       {
96559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96560       };
96561     } catch (...) {
96562       {
96563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96564       };
96565     }
96566   }
96567
96568   jresult = result;
96569   return jresult;
96570 }
96571
96572
96573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96574   unsigned long jresult ;
96575   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96576   std::size_t result;
96577
96578   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96579   {
96580     try {
96581       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);
96582     } catch (std::out_of_range& e) {
96583       {
96584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96585       };
96586     } catch (std::exception& e) {
96587       {
96588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96589       };
96590     } catch (Dali::DaliException e) {
96591       {
96592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96593       };
96594     } catch (...) {
96595       {
96596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96597       };
96598     }
96599   }
96600
96601   jresult = (unsigned long)result;
96602   return jresult;
96603 }
96604
96605
96606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96607   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96608   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96609
96610   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96611   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96612   {
96613     try {
96614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96615     } catch (std::out_of_range& e) {
96616       {
96617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96618       };
96619     } catch (std::exception& e) {
96620       {
96621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96622       };
96623     } catch (Dali::DaliException e) {
96624       {
96625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96626       };
96627     } catch (...) {
96628       {
96629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96630       };
96631     }
96632   }
96633
96634 }
96635
96636
96637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96638   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96639   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96640
96641   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96642   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96643   {
96644     try {
96645       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96646     } catch (std::out_of_range& e) {
96647       {
96648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96649       };
96650     } catch (std::exception& e) {
96651       {
96652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96653       };
96654     } catch (Dali::DaliException e) {
96655       {
96656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96657       };
96658     } catch (...) {
96659       {
96660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96661       };
96662     }
96663   }
96664
96665 }
96666
96667
96668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96669   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96670   Dali::Toolkit::PageTurnView arg2 ;
96671   unsigned int arg3 ;
96672   bool arg4 ;
96673   Dali::Toolkit::PageTurnView *argp2 ;
96674
96675   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96676   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96677   if (!argp2) {
96678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96679     return ;
96680   }
96681   arg2 = *argp2;
96682   arg3 = (unsigned int)jarg3;
96683   arg4 = jarg4 ? true : false;
96684   {
96685     try {
96686       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96687     } catch (std::out_of_range& e) {
96688       {
96689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96690       };
96691     } catch (std::exception& e) {
96692       {
96693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96694       };
96695     } catch (Dali::DaliException e) {
96696       {
96697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96698       };
96699     } catch (...) {
96700       {
96701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96702       };
96703     }
96704   }
96705
96706 }
96707
96708
96709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96710   void * jresult ;
96711   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96712
96713   {
96714     try {
96715       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96716     } catch (std::out_of_range& e) {
96717       {
96718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96719       };
96720     } catch (std::exception& e) {
96721       {
96722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96723       };
96724     } catch (Dali::DaliException e) {
96725       {
96726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96727       };
96728     } catch (...) {
96729       {
96730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96731       };
96732     }
96733   }
96734
96735   jresult = (void *)result;
96736   return jresult;
96737 }
96738
96739
96740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96741   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96742
96743   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96744   {
96745     try {
96746       delete arg1;
96747     } catch (std::out_of_range& e) {
96748       {
96749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96750       };
96751     } catch (std::exception& e) {
96752       {
96753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96754       };
96755     } catch (Dali::DaliException e) {
96756       {
96757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96758       };
96759     } catch (...) {
96760       {
96761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96762       };
96763     }
96764   }
96765
96766 }
96767
96768
96769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96770   unsigned int jresult ;
96771   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96772   bool result;
96773
96774   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96775   {
96776     try {
96777       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96778     } catch (std::out_of_range& e) {
96779       {
96780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96781       };
96782     } catch (std::exception& e) {
96783       {
96784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96785       };
96786     } catch (Dali::DaliException e) {
96787       {
96788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96789       };
96790     } catch (...) {
96791       {
96792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96793       };
96794     }
96795   }
96796
96797   jresult = result;
96798   return jresult;
96799 }
96800
96801
96802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96803   unsigned long jresult ;
96804   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96805   std::size_t result;
96806
96807   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96808   {
96809     try {
96810       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96811     } catch (std::out_of_range& e) {
96812       {
96813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96814       };
96815     } catch (std::exception& e) {
96816       {
96817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96818       };
96819     } catch (Dali::DaliException e) {
96820       {
96821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96822       };
96823     } catch (...) {
96824       {
96825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96826       };
96827     }
96828   }
96829
96830   jresult = (unsigned long)result;
96831   return jresult;
96832 }
96833
96834
96835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96836   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96837   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96838
96839   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96840   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96841   {
96842     try {
96843       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96844     } catch (std::out_of_range& e) {
96845       {
96846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96847       };
96848     } catch (std::exception& e) {
96849       {
96850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96851       };
96852     } catch (Dali::DaliException e) {
96853       {
96854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96855       };
96856     } catch (...) {
96857       {
96858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96859       };
96860     }
96861   }
96862
96863 }
96864
96865
96866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96867   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96868   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96869
96870   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96871   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96872   {
96873     try {
96874       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96875     } catch (std::out_of_range& e) {
96876       {
96877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96878       };
96879     } catch (std::exception& e) {
96880       {
96881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96882       };
96883     } catch (Dali::DaliException e) {
96884       {
96885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96886       };
96887     } catch (...) {
96888       {
96889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96890       };
96891     }
96892   }
96893
96894 }
96895
96896
96897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96898   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96899   Dali::Toolkit::PageTurnView arg2 ;
96900   Dali::Toolkit::PageTurnView *argp2 ;
96901
96902   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96903   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96904   if (!argp2) {
96905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96906     return ;
96907   }
96908   arg2 = *argp2;
96909   {
96910     try {
96911       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96912     } catch (std::out_of_range& e) {
96913       {
96914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96915       };
96916     } catch (std::exception& e) {
96917       {
96918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96919       };
96920     } catch (Dali::DaliException e) {
96921       {
96922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96923       };
96924     } catch (...) {
96925       {
96926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96927       };
96928     }
96929   }
96930
96931 }
96932
96933
96934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96935   void * jresult ;
96936   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96937
96938   {
96939     try {
96940       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96941     } catch (std::out_of_range& e) {
96942       {
96943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96944       };
96945     } catch (std::exception& e) {
96946       {
96947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96948       };
96949     } catch (Dali::DaliException e) {
96950       {
96951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96952       };
96953     } catch (...) {
96954       {
96955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96956       };
96957     }
96958   }
96959
96960   jresult = (void *)result;
96961   return jresult;
96962 }
96963
96964
96965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96966   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96967
96968   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96969   {
96970     try {
96971       delete arg1;
96972     } catch (std::out_of_range& e) {
96973       {
96974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96975       };
96976     } catch (std::exception& e) {
96977       {
96978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96979       };
96980     } catch (Dali::DaliException e) {
96981       {
96982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96983       };
96984     } catch (...) {
96985       {
96986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96987       };
96988     }
96989   }
96990
96991 }
96992
96993
96994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96995   unsigned int jresult ;
96996   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96997   bool result;
96998
96999   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97000   {
97001     try {
97002       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);
97003     } catch (std::out_of_range& e) {
97004       {
97005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97006       };
97007     } catch (std::exception& e) {
97008       {
97009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97010       };
97011     } catch (Dali::DaliException e) {
97012       {
97013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97014       };
97015     } catch (...) {
97016       {
97017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97018       };
97019     }
97020   }
97021
97022   jresult = result;
97023   return jresult;
97024 }
97025
97026
97027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97028   unsigned long jresult ;
97029   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97030   std::size_t result;
97031
97032   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97033   {
97034     try {
97035       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);
97036     } catch (std::out_of_range& e) {
97037       {
97038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97039       };
97040     } catch (std::exception& e) {
97041       {
97042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97043       };
97044     } catch (Dali::DaliException e) {
97045       {
97046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97047       };
97048     } catch (...) {
97049       {
97050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97051       };
97052     }
97053   }
97054
97055   jresult = (unsigned long)result;
97056   return jresult;
97057 }
97058
97059
97060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97061   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97062   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97063
97064   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97065   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97066   {
97067     try {
97068       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97069     } catch (std::out_of_range& e) {
97070       {
97071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97072       };
97073     } catch (std::exception& e) {
97074       {
97075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97076       };
97077     } catch (Dali::DaliException e) {
97078       {
97079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97080       };
97081     } catch (...) {
97082       {
97083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97084       };
97085     }
97086   }
97087
97088 }
97089
97090
97091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97092   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97093   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97094
97095   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97096   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97097   {
97098     try {
97099       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97100     } catch (std::out_of_range& e) {
97101       {
97102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97103       };
97104     } catch (std::exception& e) {
97105       {
97106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97107       };
97108     } catch (Dali::DaliException e) {
97109       {
97110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97111       };
97112     } catch (...) {
97113       {
97114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97115       };
97116     }
97117   }
97118
97119 }
97120
97121
97122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97123   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97124   Dali::Toolkit::ProgressBar arg2 ;
97125   float arg3 ;
97126   float arg4 ;
97127   Dali::Toolkit::ProgressBar *argp2 ;
97128
97129   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97130   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97131   if (!argp2) {
97132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97133     return ;
97134   }
97135   arg2 = *argp2;
97136   arg3 = (float)jarg3;
97137   arg4 = (float)jarg4;
97138   {
97139     try {
97140       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97141     } catch (std::out_of_range& e) {
97142       {
97143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97144       };
97145     } catch (std::exception& e) {
97146       {
97147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97148       };
97149     } catch (Dali::DaliException e) {
97150       {
97151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97152       };
97153     } catch (...) {
97154       {
97155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97156       };
97157     }
97158   }
97159
97160 }
97161
97162
97163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97164   void * jresult ;
97165   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97166
97167   {
97168     try {
97169       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97170     } catch (std::out_of_range& e) {
97171       {
97172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97173       };
97174     } catch (std::exception& e) {
97175       {
97176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97177       };
97178     } catch (Dali::DaliException e) {
97179       {
97180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97181       };
97182     } catch (...) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97185       };
97186     }
97187   }
97188
97189   jresult = (void *)result;
97190   return jresult;
97191 }
97192
97193
97194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97195   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97196
97197   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97198   {
97199     try {
97200       delete arg1;
97201     } catch (std::out_of_range& e) {
97202       {
97203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97204       };
97205     } catch (std::exception& e) {
97206       {
97207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97208       };
97209     } catch (Dali::DaliException e) {
97210       {
97211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97212       };
97213     } catch (...) {
97214       {
97215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97216       };
97217     }
97218   }
97219
97220 }
97221
97222
97223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97224   unsigned int jresult ;
97225   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97226   bool result;
97227
97228   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97229   {
97230     try {
97231       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);
97232     } catch (std::out_of_range& e) {
97233       {
97234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97235       };
97236     } catch (std::exception& e) {
97237       {
97238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97239       };
97240     } catch (Dali::DaliException e) {
97241       {
97242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97243       };
97244     } catch (...) {
97245       {
97246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97247       };
97248     }
97249   }
97250
97251   jresult = result;
97252   return jresult;
97253 }
97254
97255
97256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97257   unsigned long jresult ;
97258   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97259   std::size_t result;
97260
97261   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97262   {
97263     try {
97264       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);
97265     } catch (std::out_of_range& e) {
97266       {
97267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97268       };
97269     } catch (std::exception& e) {
97270       {
97271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97272       };
97273     } catch (Dali::DaliException e) {
97274       {
97275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97276       };
97277     } catch (...) {
97278       {
97279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97280       };
97281     }
97282   }
97283
97284   jresult = (unsigned long)result;
97285   return jresult;
97286 }
97287
97288
97289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97290   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97291   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97292
97293   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97294   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97295   {
97296     try {
97297       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97298     } catch (std::out_of_range& e) {
97299       {
97300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97301       };
97302     } catch (std::exception& e) {
97303       {
97304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97305       };
97306     } catch (Dali::DaliException e) {
97307       {
97308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97309       };
97310     } catch (...) {
97311       {
97312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97313       };
97314     }
97315   }
97316
97317 }
97318
97319
97320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97321   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97322   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97323
97324   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97325   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97326   {
97327     try {
97328       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97329     } catch (std::out_of_range& e) {
97330       {
97331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97332       };
97333     } catch (std::exception& e) {
97334       {
97335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97336       };
97337     } catch (Dali::DaliException e) {
97338       {
97339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97340       };
97341     } catch (...) {
97342       {
97343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97344       };
97345     }
97346   }
97347
97348 }
97349
97350
97351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97352   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97353   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97354
97355   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97356   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97357   if (!arg2) {
97358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97359     return ;
97360   }
97361   {
97362     try {
97363       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97364     } catch (std::out_of_range& e) {
97365       {
97366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97367       };
97368     } catch (std::exception& e) {
97369       {
97370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97371       };
97372     } catch (Dali::DaliException e) {
97373       {
97374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97375       };
97376     } catch (...) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97379       };
97380     }
97381   }
97382
97383 }
97384
97385
97386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97387   void * jresult ;
97388   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97389
97390   {
97391     try {
97392       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97393     } catch (std::out_of_range& e) {
97394       {
97395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97396       };
97397     } catch (std::exception& e) {
97398       {
97399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97400       };
97401     } catch (Dali::DaliException e) {
97402       {
97403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97404       };
97405     } catch (...) {
97406       {
97407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97408       };
97409     }
97410   }
97411
97412   jresult = (void *)result;
97413   return jresult;
97414 }
97415
97416
97417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97418   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97419
97420   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97421   {
97422     try {
97423       delete arg1;
97424     } catch (std::out_of_range& e) {
97425       {
97426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97427       };
97428     } catch (std::exception& e) {
97429       {
97430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97431       };
97432     } catch (Dali::DaliException e) {
97433       {
97434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97435       };
97436     } catch (...) {
97437       {
97438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97439       };
97440     }
97441   }
97442
97443 }
97444
97445
97446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97447   unsigned int jresult ;
97448   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97449   bool result;
97450
97451   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97452   {
97453     try {
97454       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97455     } catch (std::out_of_range& e) {
97456       {
97457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97458       };
97459     } catch (std::exception& e) {
97460       {
97461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97462       };
97463     } catch (Dali::DaliException e) {
97464       {
97465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97466       };
97467     } catch (...) {
97468       {
97469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97470       };
97471     }
97472   }
97473
97474   jresult = result;
97475   return jresult;
97476 }
97477
97478
97479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97480   unsigned long jresult ;
97481   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97482   std::size_t result;
97483
97484   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97485   {
97486     try {
97487       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97488     } catch (std::out_of_range& e) {
97489       {
97490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97491       };
97492     } catch (std::exception& e) {
97493       {
97494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97495       };
97496     } catch (Dali::DaliException e) {
97497       {
97498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97499       };
97500     } catch (...) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97503       };
97504     }
97505   }
97506
97507   jresult = (unsigned long)result;
97508   return jresult;
97509 }
97510
97511
97512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97513   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97514   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97515
97516   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97517   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97518   {
97519     try {
97520       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97521     } catch (std::out_of_range& e) {
97522       {
97523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97524       };
97525     } catch (std::exception& e) {
97526       {
97527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97528       };
97529     } catch (Dali::DaliException e) {
97530       {
97531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97532       };
97533     } catch (...) {
97534       {
97535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97536       };
97537     }
97538   }
97539
97540 }
97541
97542
97543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97544   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97545   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97546
97547   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97548   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97549   {
97550     try {
97551       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97552     } catch (std::out_of_range& e) {
97553       {
97554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97555       };
97556     } catch (std::exception& e) {
97557       {
97558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97559       };
97560     } catch (Dali::DaliException e) {
97561       {
97562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97563       };
97564     } catch (...) {
97565       {
97566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97567       };
97568     }
97569   }
97570
97571 }
97572
97573
97574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97575   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97576   Dali::Vector2 *arg2 = 0 ;
97577
97578   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97579   arg2 = (Dali::Vector2 *)jarg2;
97580   if (!arg2) {
97581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97582     return ;
97583   }
97584   {
97585     try {
97586       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97587     } catch (std::out_of_range& e) {
97588       {
97589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97590       };
97591     } catch (std::exception& e) {
97592       {
97593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97594       };
97595     } catch (Dali::DaliException e) {
97596       {
97597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97598       };
97599     } catch (...) {
97600       {
97601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97602       };
97603     }
97604   }
97605
97606 }
97607
97608
97609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97610   void * jresult ;
97611   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97612
97613   {
97614     try {
97615       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97616     } catch (std::out_of_range& e) {
97617       {
97618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97619       };
97620     } catch (std::exception& e) {
97621       {
97622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97623       };
97624     } catch (Dali::DaliException e) {
97625       {
97626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97627       };
97628     } catch (...) {
97629       {
97630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97631       };
97632     }
97633   }
97634
97635   jresult = (void *)result;
97636   return jresult;
97637 }
97638
97639
97640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97641   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97642
97643   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97644   {
97645     try {
97646       delete arg1;
97647     } catch (std::out_of_range& e) {
97648       {
97649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97650       };
97651     } catch (std::exception& e) {
97652       {
97653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97654       };
97655     } catch (Dali::DaliException e) {
97656       {
97657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97658       };
97659     } catch (...) {
97660       {
97661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97662       };
97663     }
97664   }
97665
97666 }
97667
97668
97669
97670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97671   unsigned int jresult ;
97672   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97673   bool result;
97674
97675   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97676   {
97677     try {
97678       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);
97679     } catch (std::out_of_range& e) {
97680       {
97681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97682       };
97683     } catch (std::exception& e) {
97684       {
97685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97686       };
97687     } catch (Dali::DaliException e) {
97688       {
97689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97690       };
97691     } catch (...) {
97692       {
97693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97694       };
97695     }
97696   }
97697
97698   jresult = result;
97699   return jresult;
97700 }
97701
97702
97703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97704   unsigned long jresult ;
97705   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97706   std::size_t result;
97707
97708   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97709   {
97710     try {
97711       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);
97712     } catch (std::out_of_range& e) {
97713       {
97714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97715       };
97716     } catch (std::exception& e) {
97717       {
97718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97719       };
97720     } catch (Dali::DaliException e) {
97721       {
97722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97723       };
97724     } catch (...) {
97725       {
97726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97727       };
97728     }
97729   }
97730
97731   jresult = (unsigned long)result;
97732   return jresult;
97733 }
97734
97735
97736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97737   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97738   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97739
97740   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97741   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97742   {
97743     try {
97744       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97745     } catch (std::out_of_range& e) {
97746       {
97747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97748       };
97749     } catch (std::exception& e) {
97750       {
97751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97752       };
97753     } catch (Dali::DaliException e) {
97754       {
97755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97756       };
97757     } catch (...) {
97758       {
97759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97760       };
97761     }
97762   }
97763
97764 }
97765
97766
97767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97768   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97769   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97770
97771   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97772   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97773   {
97774     try {
97775       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97776     } catch (std::out_of_range& e) {
97777       {
97778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97779       };
97780     } catch (std::exception& e) {
97781       {
97782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97783       };
97784     } catch (Dali::DaliException e) {
97785       {
97786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97787       };
97788     } catch (...) {
97789       {
97790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97791       };
97792     }
97793   }
97794
97795 }
97796
97797
97798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97799   unsigned int jresult ;
97800   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97801   Dali::Toolkit::Control arg2 ;
97802   Dali::KeyEvent *arg3 = 0 ;
97803   Dali::Toolkit::Control *argp2 ;
97804   bool result;
97805
97806   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97807   argp2 = (Dali::Toolkit::Control *)jarg2;
97808   if (!argp2) {
97809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97810     return 0;
97811   }
97812   arg2 = *argp2;
97813   arg3 = (Dali::KeyEvent *)jarg3;
97814   if (!arg3) {
97815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97816     return 0;
97817   }
97818   {
97819     try {
97820       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);
97821     } catch (std::out_of_range& e) {
97822       {
97823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97824       };
97825     } catch (std::exception& e) {
97826       {
97827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97828       };
97829     } catch (Dali::DaliException e) {
97830       {
97831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97832       };
97833     } catch (...) {
97834       {
97835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97836       };
97837     }
97838   }
97839
97840   jresult = result;
97841   return jresult;
97842 }
97843
97844
97845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97846   void * jresult ;
97847   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97848
97849   {
97850     try {
97851       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97852     } catch (std::out_of_range& e) {
97853       {
97854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97855       };
97856     } catch (std::exception& e) {
97857       {
97858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97859       };
97860     } catch (Dali::DaliException e) {
97861       {
97862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97863       };
97864     } catch (...) {
97865       {
97866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97867       };
97868     }
97869   }
97870
97871   jresult = (void *)result;
97872   return jresult;
97873 }
97874
97875
97876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97877   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97878
97879   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97880   {
97881     try {
97882       delete arg1;
97883     } catch (std::out_of_range& e) {
97884       {
97885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97886       };
97887     } catch (std::exception& e) {
97888       {
97889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97890       };
97891     } catch (Dali::DaliException e) {
97892       {
97893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97894       };
97895     } catch (...) {
97896       {
97897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97898       };
97899     }
97900   }
97901
97902 }
97903
97904
97905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97906   unsigned int jresult ;
97907   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97908   bool result;
97909
97910   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97911   {
97912     try {
97913       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97914     } catch (std::out_of_range& e) {
97915       {
97916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (std::exception& e) {
97919       {
97920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97921       };
97922     } catch (Dali::DaliException e) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97925       };
97926     } catch (...) {
97927       {
97928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97929       };
97930     }
97931   }
97932
97933   jresult = result;
97934   return jresult;
97935 }
97936
97937
97938 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97939   unsigned long jresult ;
97940   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97941   std::size_t result;
97942
97943   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97944   {
97945     try {
97946       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97947     } catch (std::out_of_range& e) {
97948       {
97949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97950       };
97951     } catch (std::exception& e) {
97952       {
97953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97954       };
97955     } catch (Dali::DaliException e) {
97956       {
97957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97958       };
97959     } catch (...) {
97960       {
97961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97962       };
97963     }
97964   }
97965
97966   jresult = (unsigned long)result;
97967   return jresult;
97968 }
97969
97970
97971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97972   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97973   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97974
97975   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97976   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97977   {
97978     try {
97979       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97980     } catch (std::out_of_range& e) {
97981       {
97982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97983       };
97984     } catch (std::exception& e) {
97985       {
97986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97987       };
97988     } catch (Dali::DaliException e) {
97989       {
97990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97991       };
97992     } catch (...) {
97993       {
97994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97995       };
97996     }
97997   }
97998
97999 }
98000
98001
98002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98003   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98004   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98005
98006   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98007   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98008   {
98009     try {
98010       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98011     } catch (std::out_of_range& e) {
98012       {
98013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98014       };
98015     } catch (std::exception& e) {
98016       {
98017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98018       };
98019     } catch (Dali::DaliException e) {
98020       {
98021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98022       };
98023     } catch (...) {
98024       {
98025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98026       };
98027     }
98028   }
98029
98030 }
98031
98032
98033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98034   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98035   Dali::Toolkit::Control arg2 ;
98036   Dali::Toolkit::Control *argp2 ;
98037
98038   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98039   argp2 = (Dali::Toolkit::Control *)jarg2;
98040   if (!argp2) {
98041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98042     return ;
98043   }
98044   arg2 = *argp2;
98045   {
98046     try {
98047       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98048     } catch (std::out_of_range& e) {
98049       {
98050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98051       };
98052     } catch (std::exception& e) {
98053       {
98054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98055       };
98056     } catch (Dali::DaliException e) {
98057       {
98058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98059       };
98060     } catch (...) {
98061       {
98062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98063       };
98064     }
98065   }
98066
98067 }
98068
98069
98070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98071   void * jresult ;
98072   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98073
98074   {
98075     try {
98076       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98077     } catch (std::out_of_range& e) {
98078       {
98079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98080       };
98081     } catch (std::exception& e) {
98082       {
98083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98084       };
98085     } catch (Dali::DaliException e) {
98086       {
98087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98088       };
98089     } catch (...) {
98090       {
98091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98092       };
98093     }
98094   }
98095
98096   jresult = (void *)result;
98097   return jresult;
98098 }
98099
98100
98101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98102   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98103
98104   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98105   {
98106     try {
98107       delete arg1;
98108     } catch (std::out_of_range& e) {
98109       {
98110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98111       };
98112     } catch (std::exception& e) {
98113       {
98114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98115       };
98116     } catch (Dali::DaliException e) {
98117       {
98118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98119       };
98120     } catch (...) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98123       };
98124     }
98125   }
98126
98127 }
98128
98129
98130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98131   unsigned int jresult ;
98132   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98133   bool result;
98134
98135   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98136   {
98137     try {
98138       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98139     } catch (std::out_of_range& e) {
98140       {
98141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98142       };
98143     } catch (std::exception& e) {
98144       {
98145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98146       };
98147     } catch (Dali::DaliException e) {
98148       {
98149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98150       };
98151     } catch (...) {
98152       {
98153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98154       };
98155     }
98156   }
98157
98158   jresult = result;
98159   return jresult;
98160 }
98161
98162
98163 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98164   unsigned long jresult ;
98165   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98166   std::size_t result;
98167
98168   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98169   {
98170     try {
98171       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98172     } catch (std::out_of_range& e) {
98173       {
98174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98175       };
98176     } catch (std::exception& e) {
98177       {
98178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98179       };
98180     } catch (Dali::DaliException e) {
98181       {
98182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98183       };
98184     } catch (...) {
98185       {
98186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98187       };
98188     }
98189   }
98190
98191   jresult = (unsigned long)result;
98192   return jresult;
98193 }
98194
98195
98196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98197   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98198   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98199
98200   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98201   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98202   {
98203     try {
98204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98205     } catch (std::out_of_range& e) {
98206       {
98207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98208       };
98209     } catch (std::exception& e) {
98210       {
98211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98212       };
98213     } catch (Dali::DaliException e) {
98214       {
98215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98216       };
98217     } catch (...) {
98218       {
98219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98220       };
98221     }
98222   }
98223
98224 }
98225
98226
98227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98228   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98229   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98230
98231   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98232   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98233   {
98234     try {
98235       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98236     } catch (std::out_of_range& e) {
98237       {
98238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98239       };
98240     } catch (std::exception& e) {
98241       {
98242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98243       };
98244     } catch (Dali::DaliException e) {
98245       {
98246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98247       };
98248     } catch (...) {
98249       {
98250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98251       };
98252     }
98253   }
98254
98255 }
98256
98257
98258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98259   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98260   Dali::Toolkit::VideoView *arg2 = 0 ;
98261
98262   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98263   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98264   if (!arg2) {
98265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98266     return ;
98267   }
98268   {
98269     try {
98270       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*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_new_VideoViewSignal() {
98294   void * jresult ;
98295   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98296
98297   {
98298     try {
98299       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98300     } catch (std::out_of_range& e) {
98301       {
98302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98303       };
98304     } catch (std::exception& e) {
98305       {
98306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98307       };
98308     } catch (Dali::DaliException e) {
98309       {
98310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98311       };
98312     } catch (...) {
98313       {
98314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98315       };
98316     }
98317   }
98318
98319   jresult = (void *)result;
98320   return jresult;
98321 }
98322
98323
98324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98325   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98326
98327   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98328   {
98329     try {
98330       delete arg1;
98331     } catch (std::out_of_range& e) {
98332       {
98333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98334       };
98335     } catch (std::exception& e) {
98336       {
98337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98338       };
98339     } catch (Dali::DaliException e) {
98340       {
98341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98342       };
98343     } catch (...) {
98344       {
98345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98346       };
98347     }
98348   }
98349
98350 }
98351
98352
98353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98354   unsigned int jresult ;
98355   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98356   bool result;
98357
98358   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98359   {
98360     try {
98361       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98362     } catch (std::out_of_range& e) {
98363       {
98364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98365       };
98366     } catch (std::exception& e) {
98367       {
98368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (Dali::DaliException e) {
98371       {
98372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98373       };
98374     } catch (...) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98377       };
98378     }
98379   }
98380
98381   jresult = result;
98382   return jresult;
98383 }
98384
98385
98386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98387   unsigned long jresult ;
98388   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98389   std::size_t result;
98390
98391   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98392   {
98393     try {
98394       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98395     } catch (std::out_of_range& e) {
98396       {
98397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98398       };
98399     } catch (std::exception& e) {
98400       {
98401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98402       };
98403     } catch (Dali::DaliException e) {
98404       {
98405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98406       };
98407     } catch (...) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98410       };
98411     }
98412   }
98413
98414   jresult = (unsigned long)result;
98415   return jresult;
98416 }
98417
98418
98419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98420   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98421   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98422
98423   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98424   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98425   {
98426     try {
98427       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98428     } catch (std::out_of_range& e) {
98429       {
98430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98431       };
98432     } catch (std::exception& e) {
98433       {
98434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98435       };
98436     } catch (Dali::DaliException e) {
98437       {
98438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98439       };
98440     } catch (...) {
98441       {
98442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98443       };
98444     }
98445   }
98446
98447 }
98448
98449
98450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98451   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98452   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98453
98454   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98455   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98456   {
98457     try {
98458       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98459     } catch (std::out_of_range& e) {
98460       {
98461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98462       };
98463     } catch (std::exception& e) {
98464       {
98465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98466       };
98467     } catch (Dali::DaliException e) {
98468       {
98469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98470       };
98471     } catch (...) {
98472       {
98473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98474       };
98475     }
98476   }
98477
98478 }
98479
98480
98481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98482   unsigned int jresult ;
98483   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98484   Dali::Toolkit::Slider arg2 ;
98485   float arg3 ;
98486   Dali::Toolkit::Slider *argp2 ;
98487   bool result;
98488
98489   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98490   argp2 = (Dali::Toolkit::Slider *)jarg2;
98491   if (!argp2) {
98492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98493     return 0;
98494   }
98495   arg2 = *argp2;
98496   arg3 = (float)jarg3;
98497   {
98498     try {
98499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98500     } catch (std::out_of_range& e) {
98501       {
98502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98503       };
98504     } catch (std::exception& e) {
98505       {
98506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98507       };
98508     } catch (Dali::DaliException e) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98511       };
98512     } catch (...) {
98513       {
98514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98515       };
98516     }
98517   }
98518
98519   jresult = result;
98520   return jresult;
98521 }
98522
98523
98524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98525   void * jresult ;
98526   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98527
98528   {
98529     try {
98530       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98531     } catch (std::out_of_range& e) {
98532       {
98533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98534       };
98535     } catch (std::exception& e) {
98536       {
98537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98538       };
98539     } catch (Dali::DaliException e) {
98540       {
98541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98542       };
98543     } catch (...) {
98544       {
98545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98546       };
98547     }
98548   }
98549
98550   jresult = (void *)result;
98551   return jresult;
98552 }
98553
98554
98555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98556   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98557
98558   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98559   {
98560     try {
98561       delete arg1;
98562     } catch (std::out_of_range& e) {
98563       {
98564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98565       };
98566     } catch (std::exception& e) {
98567       {
98568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98569       };
98570     } catch (Dali::DaliException e) {
98571       {
98572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98573       };
98574     } catch (...) {
98575       {
98576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98577       };
98578     }
98579   }
98580
98581 }
98582
98583
98584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98585   unsigned int jresult ;
98586   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98587   bool result;
98588
98589   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98590   {
98591     try {
98592       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98593     } catch (std::out_of_range& e) {
98594       {
98595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98596       };
98597     } catch (std::exception& e) {
98598       {
98599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98600       };
98601     } catch (Dali::DaliException e) {
98602       {
98603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98604       };
98605     } catch (...) {
98606       {
98607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98608       };
98609     }
98610   }
98611
98612   jresult = result;
98613   return jresult;
98614 }
98615
98616
98617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98618   unsigned long jresult ;
98619   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98620   std::size_t result;
98621
98622   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98623   {
98624     try {
98625       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98626     } catch (std::out_of_range& e) {
98627       {
98628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98629       };
98630     } catch (std::exception& e) {
98631       {
98632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98633       };
98634     } catch (Dali::DaliException e) {
98635       {
98636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98637       };
98638     } catch (...) {
98639       {
98640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98641       };
98642     }
98643   }
98644
98645   jresult = (unsigned long)result;
98646   return jresult;
98647 }
98648
98649
98650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98651   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98652   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98653
98654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98655   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98656   {
98657     try {
98658       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98659     } catch (std::out_of_range& e) {
98660       {
98661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98662       };
98663     } catch (std::exception& e) {
98664       {
98665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98666       };
98667     } catch (Dali::DaliException e) {
98668       {
98669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98670       };
98671     } catch (...) {
98672       {
98673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98674       };
98675     }
98676   }
98677
98678 }
98679
98680
98681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98682   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98683   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98684
98685   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98686   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98687   {
98688     try {
98689       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98690     } catch (std::out_of_range& e) {
98691       {
98692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98693       };
98694     } catch (std::exception& e) {
98695       {
98696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98697       };
98698     } catch (Dali::DaliException e) {
98699       {
98700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98701       };
98702     } catch (...) {
98703       {
98704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98705       };
98706     }
98707   }
98708
98709 }
98710
98711
98712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98713   unsigned int jresult ;
98714   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98715   Dali::Toolkit::Slider arg2 ;
98716   int arg3 ;
98717   Dali::Toolkit::Slider *argp2 ;
98718   bool result;
98719
98720   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98721   argp2 = (Dali::Toolkit::Slider *)jarg2;
98722   if (!argp2) {
98723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98724     return 0;
98725   }
98726   arg2 = *argp2;
98727   arg3 = (int)jarg3;
98728   {
98729     try {
98730       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98731     } catch (std::out_of_range& e) {
98732       {
98733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98734       };
98735     } catch (std::exception& e) {
98736       {
98737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98738       };
98739     } catch (Dali::DaliException e) {
98740       {
98741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98742       };
98743     } catch (...) {
98744       {
98745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98746       };
98747     }
98748   }
98749
98750   jresult = result;
98751   return jresult;
98752 }
98753
98754
98755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98756   void * jresult ;
98757   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98758
98759   {
98760     try {
98761       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98762     } catch (std::out_of_range& e) {
98763       {
98764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98765       };
98766     } catch (std::exception& e) {
98767       {
98768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98769       };
98770     } catch (Dali::DaliException e) {
98771       {
98772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98773       };
98774     } catch (...) {
98775       {
98776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98777       };
98778     }
98779   }
98780
98781   jresult = (void *)result;
98782   return jresult;
98783 }
98784
98785
98786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98787   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98788
98789   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98790   {
98791     try {
98792       delete arg1;
98793     } catch (std::out_of_range& e) {
98794       {
98795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98796       };
98797     } catch (std::exception& e) {
98798       {
98799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98800       };
98801     } catch (Dali::DaliException e) {
98802       {
98803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98804       };
98805     } catch (...) {
98806       {
98807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98808       };
98809     }
98810   }
98811
98812 }
98813
98814
98815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98816   void * jresult ;
98817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98818
98819   {
98820     try {
98821       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98822     } catch (std::out_of_range& e) {
98823       {
98824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98825       };
98826     } catch (std::exception& e) {
98827       {
98828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98829       };
98830     } catch (Dali::DaliException e) {
98831       {
98832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98833       };
98834     } catch (...) {
98835       {
98836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98837       };
98838     }
98839   }
98840
98841   jresult = (void *)result;
98842   return jresult;
98843 }
98844
98845
98846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98847   void * jresult ;
98848   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98850
98851   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98852   {
98853     try {
98854       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98855     } catch (std::out_of_range& e) {
98856       {
98857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98858       };
98859     } catch (std::exception& e) {
98860       {
98861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98862       };
98863     } catch (Dali::DaliException e) {
98864       {
98865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98866       };
98867     } catch (...) {
98868       {
98869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98870       };
98871     }
98872   }
98873
98874   jresult = (void *)result;
98875   return jresult;
98876 }
98877
98878
98879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98880   void * jresult ;
98881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98883
98884   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98885   if (!arg1) {
98886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98887     return 0;
98888   }
98889   {
98890     try {
98891       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98892     } catch (std::out_of_range& e) {
98893       {
98894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98895       };
98896     } catch (std::exception& e) {
98897       {
98898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98899       };
98900     } catch (Dali::DaliException e) {
98901       {
98902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98903       };
98904     } catch (...) {
98905       {
98906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98907       };
98908     }
98909   }
98910
98911   jresult = (void *)result;
98912   return jresult;
98913 }
98914
98915
98916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98917   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98918
98919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98920   {
98921     try {
98922       delete arg1;
98923     } catch (std::out_of_range& e) {
98924       {
98925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98926       };
98927     } catch (std::exception& e) {
98928       {
98929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98930       };
98931     } catch (Dali::DaliException e) {
98932       {
98933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98934       };
98935     } catch (...) {
98936       {
98937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98938       };
98939     }
98940   }
98941
98942 }
98943
98944
98945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98946   void * jresult ;
98947   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98948   Dali::Toolkit::Ruler *result = 0 ;
98949
98950   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98951   {
98952     try {
98953       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98954     } catch (std::out_of_range& e) {
98955       {
98956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98957       };
98958     } catch (std::exception& e) {
98959       {
98960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98961       };
98962     } catch (Dali::DaliException e) {
98963       {
98964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98965       };
98966     } catch (...) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98969       };
98970     }
98971   }
98972
98973   jresult = (void *)result;
98974   return jresult;
98975 }
98976
98977
98978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98979   void * jresult ;
98980   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98981   Dali::Toolkit::Ruler *result = 0 ;
98982
98983   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98984   {
98985     try {
98986       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98987     } catch (std::out_of_range& e) {
98988       {
98989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98990       };
98991     } catch (std::exception& e) {
98992       {
98993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98994       };
98995     } catch (Dali::DaliException e) {
98996       {
98997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98998       };
98999     } catch (...) {
99000       {
99001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99002       };
99003     }
99004   }
99005
99006   jresult = (void *)result;
99007   return jresult;
99008 }
99009
99010
99011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99012   void * jresult ;
99013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99014   Dali::Toolkit::Ruler *result = 0 ;
99015
99016   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99017   {
99018     try {
99019       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99020     } catch (std::out_of_range& e) {
99021       {
99022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99023       };
99024     } catch (std::exception& e) {
99025       {
99026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99027       };
99028     } catch (Dali::DaliException e) {
99029       {
99030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99031       };
99032     } catch (...) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99035       };
99036     }
99037   }
99038
99039   jresult = (void *)result;
99040   return jresult;
99041 }
99042
99043
99044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99045   void * jresult ;
99046   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99047   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99049
99050   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99051   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99052   if (!arg2) {
99053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99054     return 0;
99055   }
99056   {
99057     try {
99058       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99059     } catch (std::out_of_range& e) {
99060       {
99061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99062       };
99063     } catch (std::exception& e) {
99064       {
99065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99066       };
99067     } catch (Dali::DaliException e) {
99068       {
99069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99070       };
99071     } catch (...) {
99072       {
99073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99074       };
99075     }
99076   }
99077
99078   jresult = (void *)result;
99079   return jresult;
99080 }
99081
99082
99083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99084   void * jresult ;
99085   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99086   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99088
99089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99090   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99091   {
99092     try {
99093       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99094     } catch (std::out_of_range& e) {
99095       {
99096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99097       };
99098     } catch (std::exception& e) {
99099       {
99100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99101       };
99102     } catch (Dali::DaliException e) {
99103       {
99104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99105       };
99106     } catch (...) {
99107       {
99108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99109       };
99110     }
99111   }
99112
99113   jresult = (void *)result;
99114   return jresult;
99115 }
99116
99117
99118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99120
99121   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99122   {
99123     try {
99124       (arg1)->Reset();
99125     } catch (std::out_of_range& e) {
99126       {
99127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99128       };
99129     } catch (std::exception& e) {
99130       {
99131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99132       };
99133     } catch (Dali::DaliException e) {
99134       {
99135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99136       };
99137     } catch (...) {
99138       {
99139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99140       };
99141     }
99142   }
99143
99144 }
99145
99146
99147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99148   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99149   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99150
99151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99152   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99153   {
99154     try {
99155       (arg1)->Reset(arg2);
99156     } catch (std::out_of_range& e) {
99157       {
99158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99159       };
99160     } catch (std::exception& e) {
99161       {
99162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99163       };
99164     } catch (Dali::DaliException e) {
99165       {
99166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99167       };
99168     } catch (...) {
99169       {
99170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99171       };
99172     }
99173   }
99174
99175 }
99176
99177
99178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99179   void * jresult ;
99180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99181   Dali::Toolkit::Ruler *result = 0 ;
99182
99183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99184   {
99185     try {
99186       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99187     } catch (std::out_of_range& e) {
99188       {
99189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99190       };
99191     } catch (std::exception& e) {
99192       {
99193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99194       };
99195     } catch (Dali::DaliException e) {
99196       {
99197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99198       };
99199     } catch (...) {
99200       {
99201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99202       };
99203     }
99204   }
99205
99206   jresult = (void *)result;
99207   return jresult;
99208 }
99209
99210
99211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99212   float jresult ;
99213   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99214   float arg2 ;
99215   float arg3 ;
99216   float result;
99217
99218   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99219   arg2 = (float)jarg2;
99220   arg3 = (float)jarg3;
99221   {
99222     try {
99223       result = (float)(*arg1)->Snap(arg2,arg3);
99224     } catch (std::out_of_range& e) {
99225       {
99226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99227       };
99228     } catch (std::exception& e) {
99229       {
99230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99231       };
99232     } catch (Dali::DaliException e) {
99233       {
99234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99235       };
99236     } catch (...) {
99237       {
99238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99239       };
99240     }
99241   }
99242
99243   jresult = result;
99244   return jresult;
99245 }
99246
99247
99248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99249   float jresult ;
99250   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99251   float arg2 ;
99252   float result;
99253
99254   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99255   arg2 = (float)jarg2;
99256   {
99257     try {
99258       result = (float)(*arg1)->Snap(arg2);
99259     } catch (std::out_of_range& e) {
99260       {
99261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99262       };
99263     } catch (std::exception& e) {
99264       {
99265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99266       };
99267     } catch (Dali::DaliException e) {
99268       {
99269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99270       };
99271     } catch (...) {
99272       {
99273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99274       };
99275     }
99276   }
99277
99278   jresult = result;
99279   return jresult;
99280 }
99281
99282
99283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99284   float jresult ;
99285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99286   unsigned int arg2 ;
99287   unsigned int *arg3 = 0 ;
99288   bool arg4 ;
99289   float result;
99290
99291   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99292   arg2 = (unsigned int)jarg2;
99293   arg3 = (unsigned int *)jarg3;
99294   arg4 = jarg4 ? true : false;
99295   {
99296     try {
99297       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99298     } catch (std::out_of_range& e) {
99299       {
99300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99301       };
99302     } catch (std::exception& e) {
99303       {
99304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99305       };
99306     } catch (Dali::DaliException e) {
99307       {
99308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99309       };
99310     } catch (...) {
99311       {
99312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99313       };
99314     }
99315   }
99316
99317   jresult = result;
99318   return jresult;
99319 }
99320
99321
99322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99323   unsigned int jresult ;
99324   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99325   float arg2 ;
99326   bool arg3 ;
99327   unsigned int result;
99328
99329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99330   arg2 = (float)jarg2;
99331   arg3 = jarg3 ? true : false;
99332   {
99333     try {
99334       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99335     } catch (std::out_of_range& e) {
99336       {
99337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99338       };
99339     } catch (std::exception& e) {
99340       {
99341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99342       };
99343     } catch (Dali::DaliException e) {
99344       {
99345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99346       };
99347     } catch (...) {
99348       {
99349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99350       };
99351     }
99352   }
99353
99354   jresult = result;
99355   return jresult;
99356 }
99357
99358
99359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99360   unsigned int jresult ;
99361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99362   unsigned int result;
99363
99364   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99365   {
99366     try {
99367       result = (unsigned int)(*arg1)->GetTotalPages();
99368     } catch (std::out_of_range& e) {
99369       {
99370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99371       };
99372     } catch (std::exception& e) {
99373       {
99374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99375       };
99376     } catch (Dali::DaliException e) {
99377       {
99378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99379       };
99380     } catch (...) {
99381       {
99382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99383       };
99384     }
99385   }
99386
99387   jresult = result;
99388   return jresult;
99389 }
99390
99391
99392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99393   int jresult ;
99394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99395   Dali::Toolkit::Ruler::RulerType result;
99396
99397   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99398   {
99399     try {
99400       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99401     } catch (std::out_of_range& e) {
99402       {
99403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99404       };
99405     } catch (std::exception& e) {
99406       {
99407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99408       };
99409     } catch (Dali::DaliException e) {
99410       {
99411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99412       };
99413     } catch (...) {
99414       {
99415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99416       };
99417     }
99418   }
99419
99420   jresult = (int)result;
99421   return jresult;
99422 }
99423
99424
99425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99426   unsigned int jresult ;
99427   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99428   bool result;
99429
99430   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99431   {
99432     try {
99433       result = (bool)(*arg1)->IsEnabled();
99434     } catch (std::out_of_range& e) {
99435       {
99436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99437       };
99438     } catch (std::exception& e) {
99439       {
99440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99441       };
99442     } catch (Dali::DaliException e) {
99443       {
99444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99445       };
99446     } catch (...) {
99447       {
99448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99449       };
99450     }
99451   }
99452
99453   jresult = result;
99454   return jresult;
99455 }
99456
99457
99458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99459   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99460
99461   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99462   {
99463     try {
99464       (*arg1)->Enable();
99465     } catch (std::out_of_range& e) {
99466       {
99467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99468       };
99469     } catch (std::exception& e) {
99470       {
99471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99472       };
99473     } catch (Dali::DaliException e) {
99474       {
99475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99476       };
99477     } catch (...) {
99478       {
99479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99480       };
99481     }
99482   }
99483
99484 }
99485
99486
99487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99488   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99489
99490   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99491   {
99492     try {
99493       (*arg1)->Disable();
99494     } catch (std::out_of_range& e) {
99495       {
99496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99497       };
99498     } catch (std::exception& e) {
99499       {
99500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99501       };
99502     } catch (Dali::DaliException e) {
99503       {
99504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99505       };
99506     } catch (...) {
99507       {
99508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99509       };
99510     }
99511   }
99512
99513 }
99514
99515
99516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99518   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99519   Dali::Toolkit::RulerDomain *argp2 ;
99520
99521   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99522   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99523   if (!argp2) {
99524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99525     return ;
99526   }
99527   arg2 = *argp2;
99528   {
99529     try {
99530       (*arg1)->SetDomain(arg2);
99531     } catch (std::out_of_range& e) {
99532       {
99533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99534       };
99535     } catch (std::exception& e) {
99536       {
99537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99538       };
99539     } catch (Dali::DaliException e) {
99540       {
99541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99542       };
99543     } catch (...) {
99544       {
99545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99546       };
99547     }
99548   }
99549
99550 }
99551
99552
99553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99554   void * jresult ;
99555   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99556   Dali::Toolkit::RulerDomain *result = 0 ;
99557
99558   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99559   {
99560     try {
99561       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99562     } catch (std::out_of_range& e) {
99563       {
99564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99565       };
99566     } catch (std::exception& e) {
99567       {
99568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99569       };
99570     } catch (Dali::DaliException e) {
99571       {
99572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99573       };
99574     } catch (...) {
99575       {
99576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99577       };
99578     }
99579   }
99580
99581   jresult = (void *)result;
99582   return jresult;
99583 }
99584
99585
99586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99587   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99588
99589   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99590   {
99591     try {
99592       (*arg1)->DisableDomain();
99593     } catch (std::out_of_range& e) {
99594       {
99595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99596       };
99597     } catch (std::exception& e) {
99598       {
99599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99600       };
99601     } catch (Dali::DaliException e) {
99602       {
99603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99604       };
99605     } catch (...) {
99606       {
99607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99608       };
99609     }
99610   }
99611
99612 }
99613
99614
99615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99616   float jresult ;
99617   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99618   float arg2 ;
99619   float arg3 ;
99620   float arg4 ;
99621   float result;
99622
99623   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99624   arg2 = (float)jarg2;
99625   arg3 = (float)jarg3;
99626   arg4 = (float)jarg4;
99627   {
99628     try {
99629       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99630     } catch (std::out_of_range& e) {
99631       {
99632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99633       };
99634     } catch (std::exception& e) {
99635       {
99636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99637       };
99638     } catch (Dali::DaliException e) {
99639       {
99640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99641       };
99642     } catch (...) {
99643       {
99644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99645       };
99646     }
99647   }
99648
99649   jresult = result;
99650   return jresult;
99651 }
99652
99653
99654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99655   float jresult ;
99656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99657   float arg2 ;
99658   float arg3 ;
99659   float result;
99660
99661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99662   arg2 = (float)jarg2;
99663   arg3 = (float)jarg3;
99664   {
99665     try {
99666       result = (float)(*arg1)->Clamp(arg2,arg3);
99667     } catch (std::out_of_range& e) {
99668       {
99669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99670       };
99671     } catch (std::exception& e) {
99672       {
99673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99674       };
99675     } catch (Dali::DaliException e) {
99676       {
99677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99678       };
99679     } catch (...) {
99680       {
99681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99682       };
99683     }
99684   }
99685
99686   jresult = result;
99687   return jresult;
99688 }
99689
99690
99691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99692   float jresult ;
99693   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99694   float arg2 ;
99695   float result;
99696
99697   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99698   arg2 = (float)jarg2;
99699   {
99700     try {
99701       result = (float)(*arg1)->Clamp(arg2);
99702     } catch (std::out_of_range& e) {
99703       {
99704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99705       };
99706     } catch (std::exception& e) {
99707       {
99708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99709       };
99710     } catch (Dali::DaliException e) {
99711       {
99712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99713       };
99714     } catch (...) {
99715       {
99716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99717       };
99718     }
99719   }
99720
99721   jresult = result;
99722   return jresult;
99723 }
99724
99725
99726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99727   float jresult ;
99728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99729   float arg2 ;
99730   float arg3 ;
99731   float arg4 ;
99732   Dali::Toolkit::ClampState *arg5 = 0 ;
99733   float result;
99734
99735   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99736   arg2 = (float)jarg2;
99737   arg3 = (float)jarg3;
99738   arg4 = (float)jarg4;
99739   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99740   if (!arg5) {
99741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99742     return 0;
99743   }
99744   {
99745     try {
99746       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99747     } catch (std::out_of_range& e) {
99748       {
99749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99750       };
99751     } catch (std::exception& e) {
99752       {
99753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99754       };
99755     } catch (Dali::DaliException e) {
99756       {
99757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99758       };
99759     } catch (...) {
99760       {
99761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99762       };
99763     }
99764   }
99765
99766   jresult = result;
99767   return jresult;
99768 }
99769
99770
99771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99772   float jresult ;
99773   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99774   float arg2 ;
99775   float arg3 ;
99776   float arg4 ;
99777   float arg5 ;
99778   float result;
99779
99780   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99781   arg2 = (float)jarg2;
99782   arg3 = (float)jarg3;
99783   arg4 = (float)jarg4;
99784   arg5 = (float)jarg5;
99785   {
99786     try {
99787       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99788     } catch (std::out_of_range& e) {
99789       {
99790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99791       };
99792     } catch (std::exception& e) {
99793       {
99794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99795       };
99796     } catch (Dali::DaliException e) {
99797       {
99798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99799       };
99800     } catch (...) {
99801       {
99802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99803       };
99804     }
99805   }
99806
99807   jresult = result;
99808   return jresult;
99809 }
99810
99811
99812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99813   float jresult ;
99814   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99815   float arg2 ;
99816   float arg3 ;
99817   float arg4 ;
99818   float result;
99819
99820   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99821   arg2 = (float)jarg2;
99822   arg3 = (float)jarg3;
99823   arg4 = (float)jarg4;
99824   {
99825     try {
99826       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99827     } catch (std::out_of_range& e) {
99828       {
99829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99830       };
99831     } catch (std::exception& e) {
99832       {
99833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99834       };
99835     } catch (Dali::DaliException e) {
99836       {
99837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99838       };
99839     } catch (...) {
99840       {
99841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99842       };
99843     }
99844   }
99845
99846   jresult = result;
99847   return jresult;
99848 }
99849
99850
99851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99852   float jresult ;
99853   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99854   float arg2 ;
99855   float arg3 ;
99856   float result;
99857
99858   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99859   arg2 = (float)jarg2;
99860   arg3 = (float)jarg3;
99861   {
99862     try {
99863       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99864     } catch (std::out_of_range& e) {
99865       {
99866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99867       };
99868     } catch (std::exception& e) {
99869       {
99870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99871       };
99872     } catch (Dali::DaliException e) {
99873       {
99874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99875       };
99876     } catch (...) {
99877       {
99878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99879       };
99880     }
99881   }
99882
99883   jresult = result;
99884   return jresult;
99885 }
99886
99887
99888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99889   float jresult ;
99890   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99891   float arg2 ;
99892   float result;
99893
99894   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99895   arg2 = (float)jarg2;
99896   {
99897     try {
99898       result = (float)(*arg1)->SnapAndClamp(arg2);
99899     } catch (std::out_of_range& e) {
99900       {
99901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99902       };
99903     } catch (std::exception& e) {
99904       {
99905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99906       };
99907     } catch (Dali::DaliException e) {
99908       {
99909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99910       };
99911     } catch (...) {
99912       {
99913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99914       };
99915     }
99916   }
99917
99918   jresult = result;
99919   return jresult;
99920 }
99921
99922
99923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99924   float jresult ;
99925   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99926   float arg2 ;
99927   float arg3 ;
99928   float arg4 ;
99929   float arg5 ;
99930   Dali::Toolkit::ClampState *arg6 = 0 ;
99931   float result;
99932
99933   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99934   arg2 = (float)jarg2;
99935   arg3 = (float)jarg3;
99936   arg4 = (float)jarg4;
99937   arg5 = (float)jarg5;
99938   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99939   if (!arg6) {
99940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99941     return 0;
99942   }
99943   {
99944     try {
99945       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99946     } catch (std::out_of_range& e) {
99947       {
99948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99949       };
99950     } catch (std::exception& e) {
99951       {
99952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99953       };
99954     } catch (Dali::DaliException e) {
99955       {
99956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99957       };
99958     } catch (...) {
99959       {
99960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99961       };
99962     }
99963   }
99964
99965   jresult = result;
99966   return jresult;
99967 }
99968
99969
99970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99972
99973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99974   {
99975     try {
99976       (*arg1)->Reference();
99977     } catch (std::out_of_range& e) {
99978       {
99979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99980       };
99981     } catch (std::exception& e) {
99982       {
99983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99984       };
99985     } catch (Dali::DaliException e) {
99986       {
99987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99988       };
99989     } catch (...) {
99990       {
99991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99992       };
99993     }
99994   }
99995
99996 }
99997
99998
99999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100000   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100001
100002   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100003   {
100004     try {
100005       (*arg1)->Unreference();
100006     } catch (std::out_of_range& e) {
100007       {
100008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100009       };
100010     } catch (std::exception& e) {
100011       {
100012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100013       };
100014     } catch (Dali::DaliException e) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100017       };
100018     } catch (...) {
100019       {
100020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100021       };
100022     }
100023   }
100024
100025 }
100026
100027
100028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100029   int jresult ;
100030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100031   int result;
100032
100033   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100034   {
100035     try {
100036       result = (int)(*arg1)->ReferenceCount();
100037     } catch (std::out_of_range& e) {
100038       {
100039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100040       };
100041     } catch (std::exception& e) {
100042       {
100043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100044       };
100045     } catch (Dali::DaliException e) {
100046       {
100047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100048       };
100049     } catch (...) {
100050       {
100051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100052       };
100053     }
100054   }
100055
100056   jresult = result;
100057   return jresult;
100058 }
100059
100060
100061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100062   unsigned int jresult ;
100063   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100064   bool result;
100065
100066   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100067   {
100068     try {
100069       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100070     } catch (std::out_of_range& e) {
100071       {
100072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100073       };
100074     } catch (std::exception& e) {
100075       {
100076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100077       };
100078     } catch (Dali::DaliException e) {
100079       {
100080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100081       };
100082     } catch (...) {
100083       {
100084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100085       };
100086     }
100087   }
100088
100089   jresult = result;
100090   return jresult;
100091 }
100092
100093
100094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100095   unsigned long jresult ;
100096   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100097   std::size_t result;
100098
100099   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100100   {
100101     try {
100102       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100103     } catch (std::out_of_range& e) {
100104       {
100105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100106       };
100107     } catch (std::exception& e) {
100108       {
100109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100110       };
100111     } catch (Dali::DaliException e) {
100112       {
100113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100114       };
100115     } catch (...) {
100116       {
100117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100118       };
100119     }
100120   }
100121
100122   jresult = (unsigned long)result;
100123   return jresult;
100124 }
100125
100126
100127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100128   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100129   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100130
100131   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100132   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100133   {
100134     try {
100135       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100136     } catch (std::out_of_range& e) {
100137       {
100138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100139       };
100140     } catch (std::exception& e) {
100141       {
100142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100143       };
100144     } catch (Dali::DaliException e) {
100145       {
100146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100147       };
100148     } catch (...) {
100149       {
100150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100151       };
100152     }
100153   }
100154
100155 }
100156
100157
100158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100159   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100160   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100161
100162   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100163   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100164   {
100165     try {
100166       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100167     } catch (std::out_of_range& e) {
100168       {
100169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100170       };
100171     } catch (std::exception& e) {
100172       {
100173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100174       };
100175     } catch (Dali::DaliException e) {
100176       {
100177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100178       };
100179     } catch (...) {
100180       {
100181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100182       };
100183     }
100184   }
100185
100186 }
100187
100188
100189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100190   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100191   Dali::Toolkit::Control arg2 ;
100192   Dali::Toolkit::Control *argp2 ;
100193
100194   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100195   argp2 = (Dali::Toolkit::Control *)jarg2;
100196   if (!argp2) {
100197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100198     return ;
100199   }
100200   arg2 = *argp2;
100201   {
100202     try {
100203       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100204     } catch (std::out_of_range& e) {
100205       {
100206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100207       };
100208     } catch (std::exception& e) {
100209       {
100210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100211       };
100212     } catch (Dali::DaliException e) {
100213       {
100214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100215       };
100216     } catch (...) {
100217       {
100218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100219       };
100220     }
100221   }
100222
100223 }
100224
100225
100226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100227   void * jresult ;
100228   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100229
100230   {
100231     try {
100232       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100233     } catch (std::out_of_range& e) {
100234       {
100235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100236       };
100237     } catch (std::exception& e) {
100238       {
100239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100240       };
100241     } catch (Dali::DaliException e) {
100242       {
100243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100244       };
100245     } catch (...) {
100246       {
100247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100248       };
100249     }
100250   }
100251
100252   jresult = (void *)result;
100253   return jresult;
100254 }
100255
100256
100257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100258   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100259
100260   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100261   {
100262     try {
100263       delete arg1;
100264     } catch (std::out_of_range& e) {
100265       {
100266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100267       };
100268     } catch (std::exception& e) {
100269       {
100270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100271       };
100272     } catch (Dali::DaliException e) {
100273       {
100274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100275       };
100276     } catch (...) {
100277       {
100278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100279       };
100280     }
100281   }
100282
100283 }
100284
100285 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100286   Dali::RefObject *result = NULL;
100287
100288   if (arg1)
100289   {
100290     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100291   }
100292   return result;
100293 }
100294
100295 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100296     return (Dali::RefObject *)jarg1;
100297 }
100298
100299 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100300     return (Dali::SignalObserver *)jarg1;
100301 }
100302
100303 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100304     return (Dali::ConnectionTrackerInterface *)jarg1;
100305 }
100306
100307 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100308     return (Dali::BaseHandle *)jarg1;
100309 }
100310
100311 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100312     return (Dali::BaseHandle *)jarg1;
100313 }
100314
100315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100316     return (Dali::BaseHandle *)jarg1;
100317 }
100318
100319 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100320     return (Dali::BaseHandle *)jarg1;
100321 }
100322
100323 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100324     return (Dali::BaseHandle *)jarg1;
100325 }
100326
100327 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100328     return (Dali::BaseHandle *)jarg1;
100329 }
100330
100331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100332     return (Dali::BaseHandle *)jarg1;
100333 }
100334
100335 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100336     return (Dali::BaseHandle *)jarg1;
100337 }
100338
100339 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100340     return (Dali::BaseHandle *)jarg1;
100341 }
100342
100343 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100344     return (Dali::BaseHandle *)jarg1;
100345 }
100346
100347 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100348     return (Dali::BaseHandle *)jarg1;
100349 }
100350
100351 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100352     return (Dali::BaseHandle *)jarg1;
100353 }
100354
100355 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100356     return (Dali::BaseHandle *)jarg1;
100357 }
100358
100359 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100360     return (Dali::Handle *)jarg1;
100361 }
100362
100363 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100364     return (Dali::Handle *)jarg1;
100365 }
100366
100367 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100368     return (Dali::BaseHandle *)jarg1;
100369 }
100370
100371 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100372     return (Dali::BaseHandle *)jarg1;
100373 }
100374
100375 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100376     return (Dali::Handle *)jarg1;
100377 }
100378
100379 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100380     return (Dali::BaseHandle *)jarg1;
100381 }
100382
100383 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100384     return (Dali::Handle *)jarg1;
100385 }
100386
100387 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100388     return (Dali::GestureDetector *)jarg1;
100389 }
100390
100391 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100392     return (Dali::Gesture *)jarg1;
100393 }
100394
100395 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100396     return (Dali::Handle *)jarg1;
100397 }
100398
100399 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100400     return (Dali::Actor *)jarg1;
100401 }
100402
100403 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100404     return (Dali::BaseHandle *)jarg1;
100405 }
100406
100407 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100408     return (Dali::RefObject *)jarg1;
100409 }
100410
100411 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100412     return (Dali::Actor *)jarg1;
100413 }
100414
100415 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100416     return (Dali::GestureDetector *)jarg1;
100417 }
100418
100419 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100420     return (Dali::Gesture *)jarg1;
100421 }
100422
100423 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100424     return (Dali::GestureDetector *)jarg1;
100425 }
100426
100427 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100428     return (Dali::Gesture *)jarg1;
100429 }
100430
100431 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100432     return (Dali::GestureDetector *)jarg1;
100433 }
100434
100435 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100436     return (Dali::Gesture *)jarg1;
100437 }
100438
100439 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100440     return (Dali::BaseHandle *)jarg1;
100441 }
100442
100443 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100444     return (Dali::Handle *)jarg1;
100445 }
100446
100447 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100448     return (Dali::Handle *)jarg1;
100449 }
100450
100451 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100452     return (Dali::Handle *)jarg1;
100453 }
100454
100455 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100456     return (Dali::Image *)jarg1;
100457 }
100458
100459 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100460     return (Dali::Image *)jarg1;
100461 }
100462
100463 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100464     return (Dali::Image *)jarg1;
100465 }
100466
100467 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100468     return (Dali::RefObject *)jarg1;
100469 }
100470
100471 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100472     return (Dali::Image *)jarg1;
100473 }
100474
100475 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100476     return (Dali::Image *)jarg1;
100477 }
100478
100479 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100480     return (Dali::ResourceImage *)jarg1;
100481 }
100482
100483 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100484     return (Dali::Actor *)jarg1;
100485 }
100486
100487 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100488     return (Dali::BaseHandle *)jarg1;
100489 }
100490
100491 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100492     return (Dali::BaseHandle *)jarg1;
100493 }
100494
100495 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100496     return (Dali::BaseHandle *)jarg1;
100497 }
100498
100499 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100500     return (Dali::CustomActorImpl *)jarg1;
100501 }
100502
100503 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100504     return (Dali::CustomActor *)jarg1;
100505 }
100506
100507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100508     return (Dali::BaseHandle *)jarg1;
100509 }
100510
100511 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100512     return (Dali::Toolkit::Control *)jarg1;
100513 }
100514
100515 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100516     return (Dali::Toolkit::Control *)jarg1;
100517 }
100518
100519 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100520     return (Dali::Toolkit::Button *)jarg1;
100521 }
100522
100523 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100524     return (Dali::Toolkit::Button *)jarg1;
100525 }
100526
100527 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100528     return (Dali::Toolkit::Button *)jarg1;
100529 }
100530
100531 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100532     return (Dali::Toolkit::Control *)jarg1;
100533 }
100534
100535 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100536     return (Dali::Toolkit::Control *)jarg1;
100537 }
100538
100539 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100540     return (Dali::Toolkit::Control *)jarg1;
100541 }
100542
100543 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100544     return (Dali::Toolkit::Control *)jarg1;
100545 }
100546
100547 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100548     return (Dali::Toolkit::Control *)jarg1;
100549 }
100550
100551 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100552     return (Dali::RefObject *)jarg1;
100553 }
100554
100555 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100556     return (Dali::Toolkit::Scrollable *)jarg1;
100557 }
100558
100559 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100560     return (Dali::BaseHandle *)jarg1;
100561 }
100562
100563 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100564     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100565 }
100566
100567 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100568     return (Dali::RefObject *)jarg1;
100569 }
100570
100571 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100572     return (Dali::Toolkit::Ruler *)jarg1;
100573 }
100574
100575 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100576     return (Dali::Toolkit::Ruler *)jarg1;
100577 }
100578
100579 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100580     return (Dali::Toolkit::Scrollable *)jarg1;
100581 }
100582
100583 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100584     return (Dali::Toolkit::Control *)jarg1;
100585 }
100586
100587
100588 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100589     return (Dali::Toolkit::Control *)jarg1;
100590 }
100591
100592 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100593     return (Dali::BaseHandle *)jarg1;
100594 }
100595
100596 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100597     return (Dali::BaseHandle *)jarg1;
100598 }
100599
100600 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100601     return (Dali::Toolkit::Control *)jarg1;
100602 }
100603
100604 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100605     return (Dali::Toolkit::Control *)jarg1;
100606 }
100607
100608 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100609     return (Dali::Toolkit::Control *)jarg1;
100610 }
100611
100612 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100613     return (Dali::Toolkit::Control *)jarg1;
100614 }
100615
100616 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100617     return (Dali::Toolkit::Control *)jarg1;
100618 }
100619
100620 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100621     return (Dali::Toolkit::Control *)jarg1;
100622 }
100623
100624 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100625     return (Dali::Toolkit::PageTurnView *)jarg1;
100626 }
100627
100628 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100629     return (Dali::Toolkit::PageTurnView *)jarg1;
100630 }
100631
100632 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100633     return (Dali::Toolkit::Button *)jarg1;
100634 }
100635
100636 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100637     return (Dali::BaseHandle *)jarg1;
100638 }
100639
100640 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100641     return (Dali::BaseHandle *)jarg1;
100642 }
100643
100644 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100645     return (Dali::BaseHandle *)jarg1;
100646 }
100647
100648 /*
100649  * Widget binding
100650  */
100651 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100652     return (Dali::BaseHandle *)jarg1;
100653 }
100654
100655 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100656     return (Dali::BaseObject *)jarg1;
100657 }
100658
100659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100660   void * jresult ;
100661   Dali::Widget result;
100662
100663   {
100664     try {
100665       result = Dali::Widget::New();
100666     } catch (std::out_of_range& e) {
100667       {
100668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100669       };
100670     } catch (std::exception& e) {
100671       {
100672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100673       };
100674     } catch (...) {
100675       {
100676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100677       };
100678     }
100679   }
100680   jresult = new Dali::Widget((const Dali::Widget &)result);
100681   return jresult;
100682 }
100683
100684
100685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100686   void * jresult ;
100687   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100688   Dali::Widget result;
100689
100690   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100691
100692   if (!arg1) {
100693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100694     return 0;
100695   }
100696   {
100697     try {
100698       jresult = new Dali::Widget(arg1);
100699     } catch (std::out_of_range& e) {
100700       {
100701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100702       };
100703     } catch (std::exception& e) {
100704       {
100705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100706       };
100707     } catch (...) {
100708       {
100709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100710       };
100711     }
100712   }
100713   return jresult;
100714 }
100715
100716
100717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100718   void * jresult ;
100719   Dali::Widget *result = 0 ;
100720
100721   {
100722     try {
100723       result = (Dali::Widget *)new Dali::Widget();
100724     } catch (std::out_of_range& e) {
100725       {
100726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100727       };
100728     } catch (std::exception& e) {
100729       {
100730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100731       };
100732     } catch (...) {
100733       {
100734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100735       };
100736     }
100737   }
100738   jresult = (void *)result;
100739   return jresult;
100740 }
100741
100742
100743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100744   void * jresult ;
100745   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100746   Dali::Widget *arg2 = 0 ;
100747   Dali::Widget *result = 0 ;
100748
100749   arg1 = (Dali::Widget *)jarg1;
100750   arg2 = (Dali::Widget *)jarg2;
100751   if (!arg2) {
100752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100753     return 0;
100754   }
100755   {
100756     try {
100757       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100758     } catch (std::out_of_range& e) {
100759       {
100760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100761       };
100762     } catch (std::exception& e) {
100763       {
100764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100765       };
100766     } catch (...) {
100767       {
100768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100769       };
100770     }
100771   }
100772   jresult = (void *)result;
100773   return jresult;
100774 }
100775
100776
100777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100778   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100779
100780   arg1 = (Dali::Widget *)jarg1;
100781   {
100782     try {
100783       delete arg1;
100784     } catch (std::out_of_range& e) {
100785       {
100786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100787       };
100788     } catch (std::exception& e) {
100789       {
100790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100791       };
100792     } catch (...) {
100793       {
100794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100795       };
100796     }
100797   }
100798 }
100799
100800
100801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100802   void * jresult ;
100803   SwigDirector_WidgetImpl* result;
100804   {
100805     try {
100806       result = new SwigDirector_WidgetImpl();
100807     } catch (std::out_of_range& e) {
100808       {
100809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100810       };
100811     } catch (std::exception& e) {
100812       {
100813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100814       };
100815     } catch (...) {
100816       {
100817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100818       };
100819     }
100820   }
100821   jresult = result;
100822   return jresult;
100823 }
100824
100825
100826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100827   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100828   std::string *arg2 = 0 ;
100829   Dali::Window arg3 ;
100830   Dali::Window *argp3 ;
100831
100832   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100833   if (!jarg2) {
100834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100835     return ;
100836   }
100837   std::string arg2_str(jarg2);
100838   arg2 = &arg2_str;
100839   argp3 = (Dali::Window *)jarg3;
100840   if (!argp3) {
100841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100842     return ;
100843   }
100844   arg3 = *argp3;
100845   {
100846     try {
100847       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100848     } catch (std::out_of_range& e) {
100849       {
100850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100851       };
100852     } catch (std::exception& e) {
100853       {
100854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100855       };
100856     } catch (...) {
100857       {
100858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100859       };
100860     }
100861   }
100862 }
100863
100864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100865   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100866   std::string *arg2 = 0 ;
100867   Dali::Window arg3 ;
100868   Dali::Window *argp3 ;
100869
100870   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100871   if (!jarg2) {
100872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100873     return ;
100874   }
100875   std::string arg2_str(jarg2);
100876   arg2 = &arg2_str;
100877   argp3 = (Dali::Window *)jarg3;
100878   if (!argp3) {
100879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100880     return ;
100881   }
100882   arg3 = *argp3;
100883   {
100884     try {
100885       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100886     } catch (std::out_of_range& e) {
100887       {
100888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100889       };
100890     } catch (std::exception& e) {
100891       {
100892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100893       };
100894     } catch (...) {
100895       {
100896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100897       };
100898     }
100899   }
100900 }
100901
100902
100903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100904   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100905   std::string *arg2 = 0 ;
100906   Dali::Widget::Termination arg3 ;
100907
100908   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100909   if (!jarg2) {
100910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100911     return ;
100912   }
100913   std::string arg2_str(jarg2);
100914   arg2 = &arg2_str;
100915   arg3 = (Dali::Widget::Termination)jarg3;
100916   {
100917     try {
100918       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100919     } catch (std::out_of_range& e) {
100920       {
100921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100922       };
100923     } catch (std::exception& e) {
100924       {
100925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100926       };
100927     } catch (...) {
100928       {
100929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100930       };
100931     }
100932   }
100933 }
100934
100935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100936   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100937   std::string *arg2 = 0 ;
100938   Dali::Widget::Termination arg3 ;
100939
100940   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100941   if (!jarg2) {
100942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100943     return ;
100944   }
100945   std::string arg2_str(jarg2);
100946   arg2 = &arg2_str;
100947   arg3 = (Dali::Widget::Termination)jarg3;
100948   {
100949     try {
100950       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100951     } catch (std::out_of_range& e) {
100952       {
100953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100954       };
100955     } catch (std::exception& e) {
100956       {
100957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100958       };
100959     } catch (...) {
100960       {
100961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100962       };
100963     }
100964   }
100965 }
100966
100967
100968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100969   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100970
100971   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100972   {
100973     try {
100974       (arg1)->OnPause();
100975     } catch (std::out_of_range& e) {
100976       {
100977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100978       };
100979     } catch (std::exception& e) {
100980       {
100981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100982       };
100983     } catch (...) {
100984       {
100985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100986       };
100987     }
100988   }
100989 }
100990
100991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100992   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100993
100994   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100995   {
100996     try {
100997       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100998     } catch (std::out_of_range& e) {
100999       {
101000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101001       };
101002     } catch (std::exception& e) {
101003       {
101004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101005       };
101006     } catch (...) {
101007       {
101008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101009       };
101010     }
101011   }
101012 }
101013
101014
101015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101016   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101017
101018   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101019   {
101020     try {
101021       (arg1)->OnResume();
101022     } catch (std::out_of_range& e) {
101023       {
101024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101025       };
101026     } catch (std::exception& e) {
101027       {
101028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101029       };
101030     } catch (...) {
101031       {
101032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101033       };
101034     }
101035   }
101036 }
101037
101038
101039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101040   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101041
101042   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101043   {
101044     try {
101045       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101046     } catch (std::out_of_range& e) {
101047       {
101048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101049       };
101050     } catch (std::exception& e) {
101051       {
101052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101053       };
101054     } catch (...) {
101055       {
101056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101057       };
101058     }
101059   }
101060 }
101061
101062
101063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101064   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101065   Dali::Window arg2 ;
101066   Dali::Window *argp2 ;
101067
101068   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101069   argp2 = (Dali::Window *)jarg2;
101070   if (!argp2) {
101071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101072     return ;
101073   }
101074   arg2 = *argp2;
101075   {
101076     try {
101077       (arg1)->OnResize(arg2);
101078     } catch (std::out_of_range& e) {
101079       {
101080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101081       };
101082     } catch (std::exception& e) {
101083       {
101084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101085       };
101086     } catch (...) {
101087       {
101088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101089       };
101090     }
101091   }
101092 }
101093
101094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101095   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101096   Dali::Window arg2 ;
101097   Dali::Window *argp2 ;
101098
101099   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101100   argp2 = (Dali::Window *)jarg2;
101101   if (!argp2) {
101102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101103     return ;
101104   }
101105   arg2 = *argp2;
101106   {
101107     try {
101108       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101109     } catch (std::out_of_range& e) {
101110       {
101111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101112       };
101113     } catch (std::exception& e) {
101114       {
101115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101116       };
101117     } catch (...) {
101118       {
101119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101120       };
101121     }
101122   }
101123 }
101124
101125
101126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101127   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101128   std::string *arg2 = 0 ;
101129   int arg3 ;
101130
101131   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101132   if (!jarg2) {
101133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101134     return ;
101135   }
101136   std::string arg2_str(jarg2);
101137   arg2 = &arg2_str;
101138   arg3 = (int)jarg3;
101139   {
101140     try {
101141       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101142     } catch (std::out_of_range& e) {
101143       {
101144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101145       };
101146     } catch (std::exception& e) {
101147       {
101148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101149       };
101150     } catch (...) {
101151       {
101152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101153       };
101154     }
101155   }
101156 }
101157
101158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101159   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101160   std::string *arg2 = 0 ;
101161   int arg3 ;
101162
101163   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101164   if (!jarg2) {
101165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101166     return ;
101167   }
101168   std::string arg2_str(jarg2);
101169   arg2 = &arg2_str;
101170   arg3 = (int)jarg3;
101171   {
101172     try {
101173       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101174     } catch (std::out_of_range& e) {
101175       {
101176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101177       };
101178     } catch (std::exception& e) {
101179       {
101180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101181       };
101182     } catch (...) {
101183       {
101184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101185       };
101186     }
101187   }
101188 }
101189
101190
101191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101192   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101193   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101194   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101195
101196   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101197   arg2 = (Dali::SlotObserver *)jarg2;
101198   arg3 = (Dali::CallbackBase *)jarg3;
101199   {
101200     try {
101201       (arg1)->SignalConnected(arg2,arg3);
101202     } catch (std::out_of_range& e) {
101203       {
101204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101205       };
101206     } catch (std::exception& e) {
101207       {
101208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101209       };
101210     } catch (...) {
101211       {
101212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101213       };
101214     }
101215   }
101216 }
101217
101218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101219   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101220   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101221   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101222
101223   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101224   arg2 = (Dali::SlotObserver *)jarg2;
101225   arg3 = (Dali::CallbackBase *)jarg3;
101226   {
101227     try {
101228       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101229     } catch (std::out_of_range& e) {
101230       {
101231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101232       };
101233     } catch (std::exception& e) {
101234       {
101235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101236       };
101237     } catch (...) {
101238       {
101239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101240       };
101241     }
101242   }
101243 }
101244
101245
101246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101247   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101248   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101249   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101250
101251   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101252   arg2 = (Dali::SlotObserver *)jarg2;
101253   arg3 = (Dali::CallbackBase *)jarg3;
101254   {
101255     try {
101256       (arg1)->SignalDisconnected(arg2,arg3);
101257     } catch (std::out_of_range& e) {
101258       {
101259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101260       };
101261     } catch (std::exception& e) {
101262       {
101263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101264       };
101265     } catch (...) {
101266       {
101267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101268       };
101269     }
101270   }
101271 }
101272
101273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101274   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101275   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101276   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101277
101278   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101279   arg2 = (Dali::SlotObserver *)jarg2;
101280   arg3 = (Dali::CallbackBase *)jarg3;
101281   {
101282     try {
101283       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101284     } catch (std::out_of_range& e) {
101285       {
101286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101287       };
101288     } catch (std::exception& e) {
101289       {
101290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101291       };
101292     } catch (...) {
101293       {
101294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101295       };
101296     }
101297   }
101298 }
101299
101300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101301   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101302   std::string *arg2 = 0 ;
101303
101304   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101305   if (!jarg2) {
101306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101307     return ;
101308   }
101309   std::string arg2_str(jarg2);
101310   arg2 = &arg2_str;
101311   {
101312     try {
101313       (arg1)->SetContentInfo((std::string const &)*arg2);
101314     } catch (std::out_of_range& e) {
101315       {
101316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101317       };
101318     } catch (std::exception& e) {
101319       {
101320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101321       };
101322     } catch (...) {
101323       {
101324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101325       };
101326     }
101327   }
101328 }
101329
101330
101331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101332   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101333   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101334
101335   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101336   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101337   {
101338     try {
101339       (arg1)->SetImpl(arg2);
101340     } catch (std::out_of_range& e) {
101341       {
101342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101343       };
101344     } catch (std::exception& e) {
101345       {
101346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101347       };
101348     } catch (...) {
101349       {
101350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101351       };
101352     }
101353   }
101354 }
101355
101356 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) {
101357
101358   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101359   if (director) {
101360     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101361   }
101362 }
101363
101364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101365   void * jresult ;
101366   Dali::Widget *arg1 = 0 ;
101367   SwigDirector_WidgetImpl *result = 0 ;
101368
101369   arg1 = (Dali::Widget *)jarg1;
101370   if (!arg1) {
101371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101372     return 0;
101373   }
101374   {
101375     try {
101376       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101377     } catch (std::out_of_range& e) {
101378       {
101379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101380       };
101381     } catch (std::exception& e) {
101382       {
101383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101384       };
101385     } catch (...) {
101386       {
101387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101388       };
101389     }
101390   }
101391
101392   jresult = (void *)result;
101393   return jresult;
101394 }
101395
101396
101397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101398   void * jresult ;
101399   int *arg1 = (int *) 0 ;
101400   char ***arg2 ;
101401   std::string *arg3 = 0 ;
101402   Dali::WidgetApplication result;
101403   {
101404     int index = 0;
101405     int length = 0;
101406     char *retPtr;
101407     char *nextPtr;
101408     argWidgetC = jarg1;
101409     argWidgetV = new char*[jarg1 + 1];
101410
101411     retPtr = strtok_r( jarg2, " ", &nextPtr);
101412     if( retPtr )
101413     {
101414       length = strlen(retPtr);
101415     }
101416     argWidgetV[index] = new char[length + 1];
101417     if( retPtr )
101418     {
101419       strncpy(argWidgetV[index], retPtr, length);
101420     }
101421     argWidgetV[index][length] = '\0';
101422     index++;
101423
101424     while (index < jarg1)
101425     {
101426       length = 0;
101427       retPtr = strtok_r(NULL, " ", &nextPtr);
101428       if( retPtr )
101429       {
101430         length = strlen(retPtr);
101431       }
101432       argWidgetV[index] = new char[length + 1];
101433       if( retPtr )
101434       {
101435         strncpy(argWidgetV[index], retPtr, length);
101436       }
101437       argWidgetV[index][length] = '\0';
101438       index++;
101439     }
101440
101441     argWidgetV[jarg1] = NULL;
101442     argWidgetC = jarg1;
101443
101444     arg1 = &argWidgetC;
101445     arg2 = &argWidgetV;
101446   }
101447
101448   if (!jarg3) {
101449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101450     return 0;
101451   }
101452   std::string arg3_str(jarg3);
101453   arg3 = &arg3_str;
101454   {
101455     try {
101456       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101457     } catch (std::out_of_range& e) {
101458       {
101459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101460       };
101461     } catch (std::exception& e) {
101462       {
101463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101464       };
101465     } catch (...) {
101466       {
101467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101468       };
101469     }
101470   }
101471   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101472
101473   return jresult;
101474 }
101475
101476
101477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101478   void * jresult ;
101479   Dali::WidgetApplication *result = 0 ;
101480
101481   {
101482     try {
101483       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101484     } catch (std::out_of_range& e) {
101485       {
101486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101487       };
101488     } catch (std::exception& e) {
101489       {
101490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101491       };
101492     } catch (...) {
101493       {
101494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101495       };
101496     }
101497   }
101498   jresult = (void *)result;
101499   return jresult;
101500 }
101501
101502
101503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101504   void * jresult ;
101505   Dali::WidgetApplication *arg1 = 0 ;
101506   Dali::WidgetApplication *result = 0 ;
101507
101508   arg1 = (Dali::WidgetApplication *)jarg1;
101509   if (!arg1) {
101510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101511     return 0;
101512   }
101513   {
101514     try {
101515       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101516     } catch (std::out_of_range& e) {
101517       {
101518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101519       };
101520     } catch (std::exception& e) {
101521       {
101522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101523       };
101524     } catch (...) {
101525       {
101526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101527       };
101528     }
101529   }
101530   jresult = (void *)result;
101531   return jresult;
101532 }
101533
101534
101535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101536   void * jresult ;
101537   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101538   Dali::WidgetApplication *arg2 = 0 ;
101539   Dali::WidgetApplication *result = 0 ;
101540
101541   arg1 = (Dali::WidgetApplication *)jarg1;
101542   arg2 = (Dali::WidgetApplication *)jarg2;
101543   if (!arg2) {
101544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101545     return 0;
101546   }
101547   {
101548     try {
101549       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101550     } catch (std::out_of_range& e) {
101551       {
101552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101553       };
101554     } catch (std::exception& e) {
101555       {
101556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101557       };
101558     } catch (...) {
101559       {
101560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101561       };
101562     }
101563   }
101564   jresult = (void *)result;
101565   return jresult;
101566 }
101567
101568
101569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101570   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101571
101572   arg1 = (Dali::WidgetApplication *)jarg1;
101573   {
101574     try {
101575       delete arg1;
101576       if( argWidgetV )
101577       {
101578         // free string data
101579         for( int i=0; i < argWidgetC+1; i++)
101580         {
101581           delete [] argWidgetV[i];
101582         }
101583         delete [] argWidgetV;
101584       }
101585     } catch (std::out_of_range& e) {
101586       {
101587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101588       };
101589     } catch (std::exception& e) {
101590       {
101591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101592       };
101593     } catch (...) {
101594       {
101595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101596       };
101597     }
101598   }
101599 }
101600
101601
101602 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101603 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101604
101605 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101606 {
101607   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101608   return *widget;
101609 }
101610
101611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101612   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101613   std::string *arg2 = 0 ;
101614
101615   arg1 = (Dali::WidgetApplication *)jarg1;
101616   if (!jarg2) {
101617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101618     return ;
101619   }
101620   std::string arg2_str(*jarg2);
101621   arg2 = &arg2_str;
101622
101623   if(!_CSharpCreateWidgetFunction)
101624   {
101625     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101626   }
101627
101628   {
101629     try {
101630       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101631     } catch (std::out_of_range& e) {
101632       {
101633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101634       };
101635     } catch (std::exception& e) {
101636       {
101637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101638       };
101639     } catch (...) {
101640       {
101641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101642       };
101643     }
101644   }
101645
101646   //Typemap argout in c++ file.
101647   //This will convert c++ string to c# string
101648   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101649 }
101650
101651
101652 //for PixelBuffer and ImageLoading
101653
101654 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101655     return (Dali::BaseHandle *)jarg1;
101656 }
101657
101658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101659   void * jresult ;
101660   unsigned int arg1 ;
101661   unsigned int arg2 ;
101662   Dali::Pixel::Format arg3 ;
101663   Dali::Devel::PixelBuffer result;
101664
101665   arg1 = (unsigned int)jarg1;
101666   arg2 = (unsigned int)jarg2;
101667   arg3 = (Dali::Pixel::Format)jarg3;
101668   {
101669     try {
101670       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101671     } catch (std::out_of_range& e) {
101672       {
101673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101674       };
101675     } catch (std::exception& e) {
101676       {
101677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101678       };
101679     } catch (...) {
101680       {
101681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101682       };
101683     }
101684   }
101685   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101686   return jresult;
101687 }
101688
101689
101690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101691   void * jresult ;
101692   Dali::Devel::PixelBuffer *result = 0 ;
101693
101694   {
101695     try {
101696       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101697     } catch (std::out_of_range& e) {
101698       {
101699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101700       };
101701     } catch (std::exception& e) {
101702       {
101703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101704       };
101705     } catch (...) {
101706       {
101707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101708       };
101709     }
101710   }
101711   jresult = (void *)result;
101712   return jresult;
101713 }
101714
101715
101716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101717   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101718
101719   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101720   {
101721     try {
101722       delete arg1;
101723     } catch (std::out_of_range& e) {
101724       {
101725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101726       };
101727     } catch (std::exception& e) {
101728       {
101729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101730       };
101731     } catch (...) {
101732       {
101733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101734       };
101735     }
101736   }
101737 }
101738
101739
101740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101741   void * jresult ;
101742   Dali::Devel::PixelBuffer *arg1 = 0 ;
101743   Dali::Devel::PixelBuffer *result = 0 ;
101744
101745   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101746   if (!arg1) {
101747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101748     return 0;
101749   }
101750   {
101751     try {
101752       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101753     } catch (std::out_of_range& e) {
101754       {
101755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101756       };
101757     } catch (std::exception& e) {
101758       {
101759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101760       };
101761     } catch (...) {
101762       {
101763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101764       };
101765     }
101766   }
101767   jresult = (void *)result;
101768   return jresult;
101769 }
101770
101771
101772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101773   void * jresult ;
101774   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101775   Dali::Devel::PixelBuffer *arg2 = 0 ;
101776   Dali::Devel::PixelBuffer *result = 0 ;
101777
101778   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101779   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101780   if (!arg2) {
101781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101782     return 0;
101783   }
101784   {
101785     try {
101786       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101787     } catch (std::out_of_range& e) {
101788       {
101789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101790       };
101791     } catch (std::exception& e) {
101792       {
101793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101794       };
101795     } catch (...) {
101796       {
101797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101798       };
101799     }
101800   }
101801   jresult = (void *)result;
101802   return jresult;
101803 }
101804
101805
101806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101807   void * jresult ;
101808   Dali::Devel::PixelBuffer *arg1 = 0 ;
101809   Dali::PixelData result;
101810
101811   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101812   if (!arg1) {
101813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101814     return 0;
101815   }
101816   {
101817     try {
101818       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101819     } catch (std::out_of_range& e) {
101820       {
101821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101822       };
101823     } catch (std::exception& e) {
101824       {
101825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101826       };
101827     } catch (...) {
101828       {
101829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101830       };
101831     }
101832   }
101833   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101834   return jresult;
101835 }
101836
101837
101838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101839   void * jresult ;
101840   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101841   Dali::PixelData result;
101842
101843   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101844   {
101845     try {
101846       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101847     } catch (std::out_of_range& e) {
101848       {
101849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101850       };
101851     } catch (std::exception& e) {
101852       {
101853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101854       };
101855     } catch (...) {
101856       {
101857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101858       };
101859     }
101860   }
101861   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101862   return jresult;
101863 }
101864
101865
101866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101867   void * jresult ;
101868   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101869   unsigned char *result = 0 ;
101870
101871   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101872   {
101873     try {
101874       result = (unsigned char *)(arg1)->GetBuffer();
101875     } catch (std::out_of_range& e) {
101876       {
101877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101878       };
101879     } catch (std::exception& e) {
101880       {
101881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101882       };
101883     } catch (...) {
101884       {
101885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101886       };
101887     }
101888   }
101889   jresult = (void *)result;
101890   return jresult;
101891 }
101892
101893
101894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101895   unsigned int jresult ;
101896   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101897   unsigned int result;
101898
101899   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101900   {
101901     try {
101902       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101903     } catch (std::out_of_range& e) {
101904       {
101905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101906       };
101907     } catch (std::exception& e) {
101908       {
101909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101910       };
101911     } catch (...) {
101912       {
101913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101914       };
101915     }
101916   }
101917   jresult = result;
101918   return jresult;
101919 }
101920
101921
101922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101923   unsigned int jresult ;
101924   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101925   unsigned int result;
101926
101927   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101928   {
101929     try {
101930       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101931     } catch (std::out_of_range& e) {
101932       {
101933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101934       };
101935     } catch (std::exception& e) {
101936       {
101937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101938       };
101939     } catch (...) {
101940       {
101941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101942       };
101943     }
101944   }
101945   jresult = result;
101946   return jresult;
101947 }
101948
101949
101950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101951   int jresult ;
101952   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101953   Dali::Pixel::Format result;
101954
101955   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101956   {
101957     try {
101958       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101959     } catch (std::out_of_range& e) {
101960       {
101961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101962       };
101963     } catch (std::exception& e) {
101964       {
101965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101966       };
101967     } catch (...) {
101968       {
101969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101970       };
101971     }
101972   }
101973   jresult = (int)result;
101974   return jresult;
101975 }
101976
101977
101978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101979   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101980   Dali::Devel::PixelBuffer arg2 ;
101981   float arg3 ;
101982   bool arg4 ;
101983   Dali::Devel::PixelBuffer *argp2 ;
101984
101985   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101986   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101987   if (!argp2) {
101988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101989     return ;
101990   }
101991   arg2 = *argp2;
101992   arg3 = (float)jarg3;
101993   arg4 = jarg4 ? true : false;
101994   {
101995     try {
101996       (arg1)->ApplyMask(arg2,arg3,arg4);
101997     } catch (std::out_of_range& e) {
101998       {
101999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102000       };
102001     } catch (std::exception& e) {
102002       {
102003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102004       };
102005     } catch (...) {
102006       {
102007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102008       };
102009     }
102010   }
102011 }
102012
102013
102014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102015   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102016   Dali::Devel::PixelBuffer arg2 ;
102017   float arg3 ;
102018   Dali::Devel::PixelBuffer *argp2 ;
102019
102020   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102021   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102022   if (!argp2) {
102023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102024     return ;
102025   }
102026   arg2 = *argp2;
102027   arg3 = (float)jarg3;
102028   {
102029     try {
102030       (arg1)->ApplyMask(arg2,arg3);
102031     } catch (std::out_of_range& e) {
102032       {
102033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102034       };
102035     } catch (std::exception& e) {
102036       {
102037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102038       };
102039     } catch (...) {
102040       {
102041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102042       };
102043     }
102044   }
102045 }
102046
102047
102048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102049   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102050   Dali::Devel::PixelBuffer arg2 ;
102051   Dali::Devel::PixelBuffer *argp2 ;
102052
102053   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102054   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102055   if (!argp2) {
102056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102057     return ;
102058   }
102059   arg2 = *argp2;
102060   {
102061     try {
102062       (arg1)->ApplyMask(arg2);
102063     } catch (std::out_of_range& e) {
102064       {
102065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102066       };
102067     } catch (std::exception& e) {
102068       {
102069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102070       };
102071     } catch (...) {
102072       {
102073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102074       };
102075     }
102076   }
102077 }
102078
102079
102080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102081   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102082   float arg2 ;
102083
102084   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102085   arg2 = (float)jarg2;
102086   {
102087     try {
102088       (arg1)->ApplyGaussianBlur(arg2);
102089     } catch (std::out_of_range& e) {
102090       {
102091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102092       };
102093     } catch (std::exception& e) {
102094       {
102095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102096       };
102097     } catch (...) {
102098       {
102099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102100       };
102101     }
102102   }
102103 }
102104
102105
102106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102107   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102108   uint16_t arg2 ;
102109   uint16_t arg3 ;
102110   uint16_t arg4 ;
102111   uint16_t arg5 ;
102112
102113   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102114   arg2 = (uint16_t)jarg2;
102115   arg3 = (uint16_t)jarg3;
102116   arg4 = (uint16_t)jarg4;
102117   arg5 = (uint16_t)jarg5;
102118   {
102119     try {
102120       (arg1)->Crop(arg2,arg3,arg4,arg5);
102121     } catch (std::out_of_range& e) {
102122       {
102123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102124       };
102125     } catch (std::exception& e) {
102126       {
102127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102128       };
102129     } catch (...) {
102130       {
102131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102132       };
102133     }
102134   }
102135 }
102136
102137
102138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102139   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102140   uint16_t arg2 ;
102141   uint16_t arg3 ;
102142
102143   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102144   arg2 = (uint16_t)jarg2;
102145   arg3 = (uint16_t)jarg3;
102146   {
102147     try {
102148       (arg1)->Resize(arg2,arg3);
102149     } catch (std::out_of_range& e) {
102150       {
102151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102152       };
102153     } catch (std::exception& e) {
102154       {
102155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102156       };
102157     } catch (...) {
102158       {
102159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102160       };
102161     }
102162   }
102163 }
102164
102165
102166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102167   void * jresult ;
102168   std::string *arg1 = 0 ;
102169   Dali::ImageDimensions arg2 ;
102170   Dali::FittingMode::Type arg3 ;
102171   Dali::SamplingMode::Type arg4 ;
102172   bool arg5 ;
102173   Dali::ImageDimensions *argp2 ;
102174   Dali::Devel::PixelBuffer result;
102175
102176   if (!jarg1) {
102177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102178     return 0;
102179   }
102180   std::string arg1_str(jarg1);
102181   arg1 = &arg1_str;
102182   argp2 = (Dali::ImageDimensions *)jarg2;
102183   if (!argp2) {
102184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102185     return 0;
102186   }
102187   arg2 = *argp2;
102188   arg3 = (Dali::FittingMode::Type)jarg3;
102189   arg4 = (Dali::SamplingMode::Type)jarg4;
102190   arg5 = jarg5 ? true : false;
102191   {
102192     try {
102193       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102194     } catch (std::out_of_range& e) {
102195       {
102196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102197       };
102198     } catch (std::exception& e) {
102199       {
102200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102201       };
102202     } catch (...) {
102203       {
102204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102205       };
102206     }
102207   }
102208   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102209
102210   return jresult;
102211 }
102212
102213
102214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102215   void * jresult ;
102216   std::string *arg1 = 0 ;
102217   Dali::ImageDimensions arg2 ;
102218   Dali::FittingMode::Type arg3 ;
102219   Dali::SamplingMode::Type arg4 ;
102220   Dali::ImageDimensions *argp2 ;
102221   Dali::Devel::PixelBuffer result;
102222
102223   if (!jarg1) {
102224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102225     return 0;
102226   }
102227   std::string arg1_str(jarg1);
102228   arg1 = &arg1_str;
102229   argp2 = (Dali::ImageDimensions *)jarg2;
102230   if (!argp2) {
102231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102232     return 0;
102233   }
102234   arg2 = *argp2;
102235   arg3 = (Dali::FittingMode::Type)jarg3;
102236   arg4 = (Dali::SamplingMode::Type)jarg4;
102237   {
102238     try {
102239       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102240     } catch (std::out_of_range& e) {
102241       {
102242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102243       };
102244     } catch (std::exception& e) {
102245       {
102246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102247       };
102248     } catch (...) {
102249       {
102250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102251       };
102252     }
102253   }
102254   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102255
102256   return jresult;
102257 }
102258
102259
102260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102261   void * jresult ;
102262   std::string *arg1 = 0 ;
102263   Dali::ImageDimensions arg2 ;
102264   Dali::FittingMode::Type arg3 ;
102265   Dali::ImageDimensions *argp2 ;
102266   Dali::Devel::PixelBuffer result;
102267
102268   if (!jarg1) {
102269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102270     return 0;
102271   }
102272   std::string arg1_str(jarg1);
102273   arg1 = &arg1_str;
102274   argp2 = (Dali::ImageDimensions *)jarg2;
102275   if (!argp2) {
102276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102277     return 0;
102278   }
102279   arg2 = *argp2;
102280   arg3 = (Dali::FittingMode::Type)jarg3;
102281   {
102282     try {
102283       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102284     } catch (std::out_of_range& e) {
102285       {
102286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102287       };
102288     } catch (std::exception& e) {
102289       {
102290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102291       };
102292     } catch (...) {
102293       {
102294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102295       };
102296     }
102297   }
102298   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102299
102300   return jresult;
102301 }
102302
102303
102304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102305   void * jresult ;
102306   std::string *arg1 = 0 ;
102307   Dali::ImageDimensions arg2 ;
102308   Dali::ImageDimensions *argp2 ;
102309   Dali::Devel::PixelBuffer result;
102310
102311   if (!jarg1) {
102312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102313     return 0;
102314   }
102315   std::string arg1_str(jarg1);
102316   arg1 = &arg1_str;
102317   argp2 = (Dali::ImageDimensions *)jarg2;
102318   if (!argp2) {
102319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102320     return 0;
102321   }
102322   arg2 = *argp2;
102323   {
102324     try {
102325       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102326     } catch (std::out_of_range& e) {
102327       {
102328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102329       };
102330     } catch (std::exception& e) {
102331       {
102332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102333       };
102334     } catch (...) {
102335       {
102336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102337       };
102338     }
102339   }
102340   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102341
102342   return jresult;
102343 }
102344
102345
102346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102347   void * jresult ;
102348   std::string *arg1 = 0 ;
102349   Dali::Devel::PixelBuffer result;
102350
102351   if (!jarg1) {
102352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102353     return 0;
102354   }
102355   std::string arg1_str(jarg1);
102356   arg1 = &arg1_str;
102357   {
102358     try {
102359       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102360     } catch (std::out_of_range& e) {
102361       {
102362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102363       };
102364     } catch (std::exception& e) {
102365       {
102366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102367       };
102368     } catch (...) {
102369       {
102370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102371       };
102372     }
102373   }
102374   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102375
102376   return jresult;
102377 }
102378
102379
102380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102381   void * jresult ;
102382   std::string *arg1 = 0 ;
102383   Dali::ImageDimensions arg2 ;
102384   Dali::FittingMode::Type arg3 ;
102385   Dali::SamplingMode::Type arg4 ;
102386   bool arg5 ;
102387   Dali::ImageDimensions *argp2 ;
102388   Dali::ImageDimensions result;
102389
102390   if (!jarg1) {
102391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102392     return 0;
102393   }
102394   std::string arg1_str(jarg1);
102395   arg1 = &arg1_str;
102396   argp2 = (Dali::ImageDimensions *)jarg2;
102397   if (!argp2) {
102398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102399     return 0;
102400   }
102401   arg2 = *argp2;
102402   arg3 = (Dali::FittingMode::Type)jarg3;
102403   arg4 = (Dali::SamplingMode::Type)jarg4;
102404   arg5 = jarg5 ? true : false;
102405   {
102406     try {
102407       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102408     } catch (std::out_of_range& e) {
102409       {
102410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102411       };
102412     } catch (std::exception& e) {
102413       {
102414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102415       };
102416     } catch (...) {
102417       {
102418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102419       };
102420     }
102421   }
102422   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102423
102424   return jresult;
102425 }
102426
102427
102428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102429   void * jresult ;
102430   std::string *arg1 = 0 ;
102431   Dali::ImageDimensions arg2 ;
102432   Dali::FittingMode::Type arg3 ;
102433   Dali::SamplingMode::Type arg4 ;
102434   Dali::ImageDimensions *argp2 ;
102435   Dali::ImageDimensions result;
102436
102437   if (!jarg1) {
102438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102439     return 0;
102440   }
102441   std::string arg1_str(jarg1);
102442   arg1 = &arg1_str;
102443   argp2 = (Dali::ImageDimensions *)jarg2;
102444   if (!argp2) {
102445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102446     return 0;
102447   }
102448   arg2 = *argp2;
102449   arg3 = (Dali::FittingMode::Type)jarg3;
102450   arg4 = (Dali::SamplingMode::Type)jarg4;
102451   {
102452     try {
102453       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102454     } catch (std::out_of_range& e) {
102455       {
102456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102457       };
102458     } catch (std::exception& e) {
102459       {
102460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102461       };
102462     } catch (...) {
102463       {
102464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102465       };
102466     }
102467   }
102468   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102469
102470   return jresult;
102471 }
102472
102473
102474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102475   void * jresult ;
102476   std::string *arg1 = 0 ;
102477   Dali::ImageDimensions arg2 ;
102478   Dali::FittingMode::Type arg3 ;
102479   Dali::ImageDimensions *argp2 ;
102480   Dali::ImageDimensions result;
102481
102482   if (!jarg1) {
102483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102484     return 0;
102485   }
102486   std::string arg1_str(jarg1);
102487   arg1 = &arg1_str;
102488   argp2 = (Dali::ImageDimensions *)jarg2;
102489   if (!argp2) {
102490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102491     return 0;
102492   }
102493   arg2 = *argp2;
102494   arg3 = (Dali::FittingMode::Type)jarg3;
102495   {
102496     try {
102497       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102498     } catch (std::out_of_range& e) {
102499       {
102500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102501       };
102502     } catch (std::exception& e) {
102503       {
102504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102505       };
102506     } catch (...) {
102507       {
102508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102509       };
102510     }
102511   }
102512   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102513
102514   return jresult;
102515 }
102516
102517
102518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102519   void * jresult ;
102520   std::string *arg1 = 0 ;
102521   Dali::ImageDimensions arg2 ;
102522   Dali::ImageDimensions *argp2 ;
102523   Dali::ImageDimensions result;
102524
102525   if (!jarg1) {
102526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102527     return 0;
102528   }
102529   std::string arg1_str(jarg1);
102530   arg1 = &arg1_str;
102531   argp2 = (Dali::ImageDimensions *)jarg2;
102532   if (!argp2) {
102533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102534     return 0;
102535   }
102536   arg2 = *argp2;
102537   {
102538     try {
102539       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102540     } catch (std::out_of_range& e) {
102541       {
102542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102543       };
102544     } catch (std::exception& e) {
102545       {
102546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102547       };
102548     } catch (...) {
102549       {
102550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102551       };
102552     }
102553   }
102554   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102555
102556   return jresult;
102557 }
102558
102559
102560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102561   void * jresult ;
102562   std::string *arg1 = 0 ;
102563   Dali::ImageDimensions result;
102564
102565   if (!jarg1) {
102566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102567     return 0;
102568   }
102569   std::string arg1_str(jarg1);
102570   arg1 = &arg1_str;
102571   {
102572     try {
102573       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102574     } catch (std::out_of_range& e) {
102575       {
102576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102577       };
102578     } catch (std::exception& e) {
102579       {
102580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102581       };
102582     } catch (...) {
102583       {
102584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102585       };
102586     }
102587   }
102588   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102589
102590   return jresult;
102591 }
102592
102593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102594   void * jresult ;
102595   std::string *arg1 = 0 ;
102596   Dali::ImageDimensions result;
102597
102598   if (!jarg1) {
102599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102600     return 0;
102601   }
102602   std::string arg1_str(jarg1);
102603   arg1 = &arg1_str;
102604   {
102605     try {
102606       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102607     } catch (std::out_of_range& e) {
102608       {
102609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102610       };
102611     } catch (std::exception& e) {
102612       {
102613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102614       };
102615     } catch (...) {
102616       {
102617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102618       };
102619     }
102620   }
102621   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102622
102623   return jresult;
102624 }
102625
102626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102627   void * jresult ;
102628   std::string *arg1 = 0 ;
102629   Dali::ImageDimensions arg2 ;
102630   Dali::FittingMode::Type arg3 ;
102631   Dali::SamplingMode::Type arg4 ;
102632   bool arg5 ;
102633   Dali::ImageDimensions *argp2 ;
102634   Dali::Devel::PixelBuffer result;
102635
102636   if (!jarg1) {
102637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102638     return 0;
102639   }
102640   std::string arg1_str(jarg1);
102641   arg1 = &arg1_str;
102642   argp2 = (Dali::ImageDimensions *)jarg2;
102643   if (!argp2) {
102644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102645     return 0;
102646   }
102647   arg2 = *argp2;
102648   arg3 = (Dali::FittingMode::Type)jarg3;
102649   arg4 = (Dali::SamplingMode::Type)jarg4;
102650   arg5 = jarg5 ? true : false;
102651   {
102652     try {
102653       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102654     } catch (std::out_of_range& e) {
102655       {
102656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102657       };
102658     } catch (std::exception& e) {
102659       {
102660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102661       };
102662     } catch (...) {
102663       {
102664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102665       };
102666     }
102667   }
102668   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102669
102670   return jresult;
102671 }
102672
102673
102674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102675   void * jresult ;
102676   std::string *arg1 = 0 ;
102677   Dali::ImageDimensions arg2 ;
102678   Dali::FittingMode::Type arg3 ;
102679   Dali::SamplingMode::Type arg4 ;
102680   Dali::ImageDimensions *argp2 ;
102681   Dali::Devel::PixelBuffer result;
102682
102683   if (!jarg1) {
102684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102685     return 0;
102686   }
102687   std::string arg1_str(jarg1);
102688   arg1 = &arg1_str;
102689   argp2 = (Dali::ImageDimensions *)jarg2;
102690   if (!argp2) {
102691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102692     return 0;
102693   }
102694   arg2 = *argp2;
102695   arg3 = (Dali::FittingMode::Type)jarg3;
102696   arg4 = (Dali::SamplingMode::Type)jarg4;
102697   {
102698     try {
102699       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102700     } catch (std::out_of_range& e) {
102701       {
102702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102703       };
102704     } catch (std::exception& e) {
102705       {
102706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102707       };
102708     } catch (...) {
102709       {
102710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102711       };
102712     }
102713   }
102714   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102715
102716   return jresult;
102717 }
102718
102719
102720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102721   void * jresult ;
102722   std::string *arg1 = 0 ;
102723   Dali::ImageDimensions arg2 ;
102724   Dali::FittingMode::Type arg3 ;
102725   Dali::ImageDimensions *argp2 ;
102726   Dali::Devel::PixelBuffer result;
102727
102728   if (!jarg1) {
102729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102730     return 0;
102731   }
102732   std::string arg1_str(jarg1);
102733   arg1 = &arg1_str;
102734   argp2 = (Dali::ImageDimensions *)jarg2;
102735   if (!argp2) {
102736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102737     return 0;
102738   }
102739   arg2 = *argp2;
102740   arg3 = (Dali::FittingMode::Type)jarg3;
102741   {
102742     try {
102743       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102744     } catch (std::out_of_range& e) {
102745       {
102746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102747       };
102748     } catch (std::exception& e) {
102749       {
102750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102751       };
102752     } catch (...) {
102753       {
102754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102755       };
102756     }
102757   }
102758   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102759
102760   return jresult;
102761 }
102762
102763
102764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102765   void * jresult ;
102766   std::string *arg1 = 0 ;
102767   Dali::ImageDimensions arg2 ;
102768   Dali::ImageDimensions *argp2 ;
102769   Dali::Devel::PixelBuffer result;
102770
102771   if (!jarg1) {
102772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102773     return 0;
102774   }
102775   std::string arg1_str(jarg1);
102776   arg1 = &arg1_str;
102777   argp2 = (Dali::ImageDimensions *)jarg2;
102778   if (!argp2) {
102779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102780     return 0;
102781   }
102782   arg2 = *argp2;
102783   {
102784     try {
102785       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102786     } catch (std::out_of_range& e) {
102787       {
102788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102789       };
102790     } catch (std::exception& e) {
102791       {
102792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102793       };
102794     } catch (...) {
102795       {
102796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102797       };
102798     }
102799   }
102800   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102801
102802   return jresult;
102803 }
102804
102805
102806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102807   void * jresult ;
102808   std::string *arg1 = 0 ;
102809   Dali::Devel::PixelBuffer result;
102810
102811   if (!jarg1) {
102812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102813     return 0;
102814   }
102815   std::string arg1_str(jarg1);
102816   arg1 = &arg1_str;
102817   {
102818     try {
102819       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102820     } catch (std::out_of_range& e) {
102821       {
102822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102823       };
102824     } catch (std::exception& e) {
102825       {
102826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102827       };
102828     } catch (...) {
102829       {
102830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102831       };
102832     }
102833   }
102834   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102835
102836   return jresult;
102837 }
102838
102839
102840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102841   void * jresult ;
102842   Dali::Toolkit::WebView result;
102843
102844   {
102845     try {
102846       result = Dali::Toolkit::WebView::New();
102847     } catch (std::out_of_range& e) {
102848       {
102849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102850       };
102851     } catch (std::exception& e) {
102852       {
102853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102854       };
102855     } catch (Dali::DaliException e) {
102856       {
102857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102858       };
102859     } catch (...) {
102860       {
102861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102862       };
102863     }
102864   }
102865   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102866   return jresult;
102867 }
102868
102869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102870   void * jresult ;
102871   Dali::Toolkit::WebView result;
102872
102873   std::string *arg1;
102874   std::string *arg2;
102875
102876   if (!jarg1) {
102877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102878     return 0;
102879   }
102880   if (!jarg2) {
102881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102882     return 0;
102883   }
102884
102885   std::string jarg1_str = std::string(jarg1);
102886   std::string jarg2_str = std::string(jarg2);
102887
102888   arg1 = &jarg1_str;
102889   arg2 = &jarg2_str;
102890
102891   {
102892     try {
102893       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102894     } catch (std::out_of_range& e) {
102895       {
102896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102897       };
102898     } catch (std::exception& e) {
102899       {
102900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102901       };
102902     } catch (Dali::DaliException e) {
102903       {
102904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102905       };
102906     } catch (...) {
102907       {
102908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102909       };
102910     }
102911   }
102912   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102913   return jresult;
102914 }
102915
102916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102917   void * jresult ;
102918   Dali::Toolkit::WebView *arg1 = 0 ;
102919   Dali::Toolkit::WebView *result = 0 ;
102920
102921   arg1 = (Dali::Toolkit::WebView *)jarg1;
102922   if (!arg1) {
102923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102924     return 0;
102925   }
102926   {
102927     try {
102928       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102929     } catch (std::out_of_range& e) {
102930       {
102931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102932       };
102933     } catch (std::exception& e) {
102934       {
102935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102936       };
102937     } catch (Dali::DaliException e) {
102938       {
102939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102940       };
102941     } catch (...) {
102942       {
102943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102944       };
102945     }
102946   }
102947   jresult = (void *)result;
102948   return jresult;
102949 }
102950
102951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102952   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102953   arg1 = (Dali::Toolkit::WebView *)jarg1;
102954   {
102955     try {
102956       delete arg1;
102957     } catch (std::out_of_range& e) {
102958       {
102959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102960       };
102961     } catch (std::exception& e) {
102962       {
102963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102964       };
102965     } catch (Dali::DaliException e) {
102966       {
102967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102968       };
102969     } catch (...) {
102970       {
102971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102972       };
102973     }
102974   }
102975 }
102976
102977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102978   void * jresult ;
102979   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102980   Dali::Toolkit::WebView *arg2 = 0 ;
102981   Dali::Toolkit::WebView *result = 0 ;
102982
102983   arg1 = (Dali::Toolkit::WebView *)jarg1;
102984   arg2 = (Dali::Toolkit::WebView *)jarg2;
102985   if (!arg2) {
102986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102987     return 0;
102988   }
102989   {
102990     try {
102991       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102992     } catch (std::out_of_range& e) {
102993       {
102994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102995       };
102996     } catch (std::exception& e) {
102997       {
102998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102999       };
103000     } catch (Dali::DaliException e) {
103001       {
103002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103003       };
103004     } catch (...) {
103005       {
103006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103007       };
103008     }
103009   }
103010   jresult = (void *)result;
103011   return jresult;
103012 }
103013
103014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103015   void * jresult ;
103016   Dali::BaseHandle arg1 ;
103017   Dali::BaseHandle *argp1 ;
103018   Dali::Toolkit::WebView result;
103019
103020   argp1 = (Dali::BaseHandle *)jarg1;
103021   if (!argp1) {
103022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103023     return 0;
103024   }
103025   arg1 = *argp1;
103026   {
103027     try {
103028       result = Dali::Toolkit::WebView::DownCast(arg1);
103029     } catch (std::out_of_range& e) {
103030       {
103031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103032       };
103033     } catch (std::exception& e) {
103034       {
103035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103036       };
103037     } catch (Dali::DaliException e) {
103038       {
103039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103040       };
103041     } catch (...) {
103042       {
103043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103044       };
103045     }
103046   }
103047   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103048   return jresult;
103049 }
103050
103051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103052   return (int) Dali::Toolkit::WebView::Property::URL;
103053 }
103054
103055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103056   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103057 }
103058
103059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103060   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103061 }
103062
103063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103064   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103065 }
103066
103067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103068   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103069 }
103070
103071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103072   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103073 }
103074
103075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103076   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103077 }
103078
103079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103080   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103081 }
103082
103083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103084   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103085   std::string *arg2;
103086
103087   arg1 = (Dali::Toolkit::WebView *)jarg1;
103088
103089   if (!jarg2) {
103090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103091     return;
103092   }
103093
103094   std::string jarg2str = std::string(jarg2);
103095   arg2 = &jarg2str;
103096   {
103097     try {
103098       (arg1)->LoadUrl((std::string const &)*arg2);
103099     } catch (std::out_of_range& e) {
103100       {
103101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103102       };
103103     } catch (std::exception& e) {
103104       {
103105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103106       };
103107     } catch (Dali::DaliException e) {
103108       {
103109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103110       };
103111     } catch (...) {
103112       {
103113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103114       };
103115     }
103116   }
103117 }
103118
103119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103120   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103121   std::string *arg2;
103122
103123   arg1 = (Dali::Toolkit::WebView *)jarg1;
103124   if (!jarg2) {
103125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103126     return;
103127   }
103128   std::string jarg2str = std::string(jarg2);
103129   arg2 = &jarg2str;
103130   {
103131     try {
103132       (arg1)->LoadHTMLString((std::string const &)*arg2);
103133     } catch (std::out_of_range& e) {
103134       {
103135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103136       };
103137     } catch (std::exception& e) {
103138       {
103139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103140       };
103141     } catch (Dali::DaliException e) {
103142       {
103143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103144       };
103145     } catch (...) {
103146       {
103147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103148       };
103149     }
103150   }
103151 }
103152
103153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103154   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103155
103156   arg1 = (Dali::Toolkit::WebView *)jarg1;
103157   {
103158     try {
103159       (arg1)->Reload();
103160     } catch (std::out_of_range& e) {
103161       {
103162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103163       };
103164     } catch (std::exception& e) {
103165       {
103166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103167       };
103168     } catch (Dali::DaliException e) {
103169       {
103170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103171       };
103172     } catch (...) {
103173       {
103174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103175       };
103176     }
103177   }
103178 }
103179
103180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103181   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103182
103183   arg1 = (Dali::Toolkit::WebView *)jarg1;
103184   {
103185     try {
103186       (arg1)->StopLoading();
103187     } catch (std::out_of_range& e) {
103188       {
103189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103190       };
103191     } catch (std::exception& e) {
103192       {
103193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103194       };
103195     } catch (Dali::DaliException e) {
103196       {
103197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103198       };
103199     } catch (...) {
103200       {
103201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103202       };
103203     }
103204   }
103205 }
103206
103207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103208   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103209
103210   arg1 = (Dali::Toolkit::WebView *)jarg1;
103211   {
103212     try {
103213       (arg1)->Suspend();
103214     } catch (std::out_of_range& e) {
103215       {
103216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103217       };
103218     } catch (std::exception& e) {
103219       {
103220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103221       };
103222     } catch (Dali::DaliException e) {
103223       {
103224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103225       };
103226     } catch (...) {
103227       {
103228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103229       };
103230     }
103231   }
103232 }
103233
103234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103235   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103236
103237   arg1 = (Dali::Toolkit::WebView *)jarg1;
103238   {
103239     try {
103240       (arg1)->Resume();
103241     } catch (std::out_of_range& e) {
103242       {
103243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103244       };
103245     } catch (std::exception& e) {
103246       {
103247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103248       };
103249     } catch (Dali::DaliException e) {
103250       {
103251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103252       };
103253     } catch (...) {
103254       {
103255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103256       };
103257     }
103258   }
103259 }
103260
103261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103262   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103263
103264   arg1 = (Dali::Toolkit::WebView *)jarg1;
103265   {
103266     try {
103267       (arg1)->GoBack();
103268     } catch (std::out_of_range& e) {
103269       {
103270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103271       };
103272     } catch (std::exception& e) {
103273       {
103274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103275       };
103276     } catch (Dali::DaliException e) {
103277       {
103278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103279       };
103280     } catch (...) {
103281       {
103282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103283       };
103284     }
103285   }
103286 }
103287
103288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103289   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103290
103291   arg1 = (Dali::Toolkit::WebView *)jarg1;
103292   {
103293     try {
103294       (arg1)->GoForward();
103295     } catch (std::out_of_range& e) {
103296       {
103297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103298       };
103299     } catch (std::exception& e) {
103300       {
103301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103302       };
103303     } catch (Dali::DaliException e) {
103304       {
103305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103306       };
103307     } catch (...) {
103308       {
103309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103310       };
103311     }
103312   }
103313 }
103314
103315 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103316   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103317   bool ret;
103318
103319   arg1 = (Dali::Toolkit::WebView *)jarg1;
103320   {
103321     try {
103322       ret = (arg1)->CanGoBack();
103323     } catch (std::out_of_range& e) {
103324       {
103325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103326       };
103327     } catch (std::exception& e) {
103328       {
103329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103330       };
103331     } catch (Dali::DaliException e) {
103332       {
103333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103334       };
103335     } catch (...) {
103336       {
103337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103338       };
103339     }
103340   }
103341   return ret;
103342 }
103343
103344 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103345   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103346   bool ret;
103347
103348   arg1 = (Dali::Toolkit::WebView *)jarg1;
103349   {
103350     try {
103351       ret = (arg1)->CanGoForward();
103352     } catch (std::out_of_range& e) {
103353       {
103354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103355       };
103356     } catch (std::exception& e) {
103357       {
103358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103359       };
103360     } catch (Dali::DaliException e) {
103361       {
103362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103363       };
103364     } catch (...) {
103365       {
103366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103367       };
103368     }
103369   }
103370   return ret;
103371 }
103372
103373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103374   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103375   std::string *arg2;
103376
103377   arg1 = (Dali::Toolkit::WebView *)jarg1;
103378   if (!jarg2) {
103379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103380     return;
103381   }
103382   std::string jarg2_str = std::string(jarg2);
103383   arg2 = &jarg2_str;
103384
103385   void (*handler)(char*) = (void (*)(char*)) jarg3;
103386
103387   {
103388     try {
103389       (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103390         handler(SWIG_csharp_string_callback(result.c_str()));
103391       });
103392     } catch (std::out_of_range& e) {
103393       {
103394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103395       };
103396     } catch (std::exception& e) {
103397       {
103398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103399       };
103400     } catch (Dali::DaliException e) {
103401       {
103402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103403       };
103404     } catch (...) {
103405       {
103406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103407       };
103408     }
103409   }
103410 }
103411
103412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103413 {
103414   if (!jarg2) {
103415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103416     return;
103417   }
103418
103419   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103420   std::string exposedObjectName = jarg2;
103421   void (*handler)(char*) = (void (*)(char*)) jarg3;
103422
103423   {
103424     try {
103425       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103426         handler(SWIG_csharp_string_callback(message.c_str()));
103427       });
103428     } catch (std::out_of_range& e) {
103429       {
103430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103431       };
103432     } catch (std::exception& e) {
103433       {
103434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103435       };
103436     } catch (Dali::DaliException e) {
103437       {
103438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103439       };
103440     } catch (...) {
103441       {
103442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103443       };
103444     }
103445   }
103446 }
103447
103448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103449   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103450
103451   arg1 = (Dali::Toolkit::WebView *)jarg1;
103452   {
103453     try {
103454       (arg1)->ClearHistory();
103455     } catch (std::out_of_range& e) {
103456       {
103457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103458       };
103459     } catch (std::exception& e) {
103460       {
103461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103462       };
103463     } catch (Dali::DaliException e) {
103464       {
103465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103466       };
103467     } catch (...) {
103468       {
103469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103470       };
103471     }
103472   }
103473 }
103474
103475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103476   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103477
103478   arg1 = (Dali::Toolkit::WebView *)jarg1;
103479   {
103480     try {
103481       (arg1)->ClearCache();
103482     } catch (std::out_of_range& e) {
103483       {
103484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103485       };
103486     } catch (std::exception& e) {
103487       {
103488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103489       };
103490     } catch (Dali::DaliException e) {
103491       {
103492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103493       };
103494     } catch (...) {
103495       {
103496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103497       };
103498     }
103499   }
103500 }
103501
103502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103503   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103504
103505   arg1 = (Dali::Toolkit::WebView *)jarg1;
103506   {
103507     try {
103508       (arg1)->ClearCookies();
103509     } catch (std::out_of_range& e) {
103510       {
103511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103512       };
103513     } catch (std::exception& e) {
103514       {
103515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103516       };
103517     } catch (Dali::DaliException e) {
103518       {
103519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103520       };
103521     } catch (...) {
103522       {
103523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103524       };
103525     }
103526   }
103527 }
103528
103529 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103530     return (Dali::Toolkit::Control *)jarg1;
103531 }
103532
103533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103534   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103535   SignalConverter::WebViewPageLoadSignal* result = NULL;
103536   {
103537     try {
103538       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103539     } catch (std::out_of_range& e) {
103540       {
103541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103542       };
103543     } catch (std::exception& e) {
103544       {
103545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103546       };
103547     } catch (Dali::DaliException e) {
103548       {
103549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103550       };
103551     } catch (...) {
103552       {
103553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103554       };
103555     }
103556   }
103557   return (void*) result;
103558 }
103559
103560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103561   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103562   SignalConverter::WebViewPageLoadSignal* result = NULL;
103563   {
103564     try {
103565       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103566     } catch (std::out_of_range& e) {
103567       {
103568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103569       };
103570     } catch (std::exception& e) {
103571       {
103572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103573       };
103574     } catch (Dali::DaliException e) {
103575       {
103576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103577       };
103578     } catch (...) {
103579       {
103580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103581       };
103582     }
103583   }
103584   return (void*) result;
103585 }
103586
103587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103588 {
103589   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103590   {
103591     try {
103592       delete object;
103593     } catch (std::out_of_range& e) {
103594       {
103595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103596       };
103597     } catch (std::exception& e) {
103598       {
103599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103600       };
103601     } catch (Dali::DaliException e) {
103602       {
103603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103604       };
103605     } catch (...) {
103606       {
103607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103608       };
103609     }
103610   }
103611 }
103612
103613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103614 {
103615   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103616   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103617   {
103618     try {
103619       proxy->Connect(callback);
103620     } catch (std::out_of_range& e) {
103621       {
103622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103623       };
103624     } catch (std::exception& e) {
103625       {
103626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103627       };
103628     } catch (Dali::DaliException e) {
103629       {
103630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103631       };
103632     } catch (...) {
103633       {
103634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103635       };
103636     }
103637   }
103638 }
103639
103640
103641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103642   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103643   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103644   {
103645     try {
103646       proxy->Disconnect(callback);
103647     } catch (std::out_of_range& e) {
103648       {
103649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103650       };
103651     } catch (std::exception& e) {
103652       {
103653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103654       };
103655     } catch (Dali::DaliException e) {
103656       {
103657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103658       };
103659     } catch (...) {
103660       {
103661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103662       };
103663     }
103664   }
103665 }
103666
103667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103668   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103669   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103670   {
103671     try {
103672       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103673     } catch (std::out_of_range& e) {
103674       {
103675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103676       };
103677     } catch (std::exception& e) {
103678       {
103679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103680       };
103681     } catch (Dali::DaliException e) {
103682       {
103683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103684       };
103685     } catch (...) {
103686       {
103687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103688       };
103689     }
103690   }
103691   return (void*) result;
103692 }
103693
103694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103695 {
103696   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103697   {
103698     try {
103699       delete object;
103700     } catch (std::out_of_range& e) {
103701       {
103702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103703       };
103704     } catch (std::exception& e) {
103705       {
103706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103707       };
103708     } catch (Dali::DaliException e) {
103709       {
103710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103711       };
103712     } catch (...) {
103713       {
103714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103715       };
103716     }
103717   }
103718 }
103719
103720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103721 {
103722   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103723   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103724   {
103725     try {
103726       proxy->Connect(callback);
103727     } catch (std::out_of_range& e) {
103728       {
103729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103730       };
103731     } catch (std::exception& e) {
103732       {
103733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103734       };
103735     } catch (Dali::DaliException e) {
103736       {
103737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103738       };
103739     } catch (...) {
103740       {
103741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103742       };
103743     }
103744   }
103745 }
103746
103747
103748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103749   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103750   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103751   {
103752     try {
103753       proxy->Disconnect(callback);
103754     } catch (std::out_of_range& e) {
103755       {
103756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103757       };
103758     } catch (std::exception& e) {
103759       {
103760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103761       };
103762     } catch (Dali::DaliException e) {
103763       {
103764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103765       };
103766     } catch (...) {
103767       {
103768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103769       };
103770     }
103771   }
103772 }
103773
103774 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103775   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103776   char * jresult = SWIG_csharp_string_callback((const char *)result);
103777   return jresult;
103778 }
103779
103780 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103781   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103782   return result;
103783 }
103784
103785 #ifdef __cplusplus
103786 }
103787 #endif
103788